Android Studio: Glas als Bibliothek hinzufügen?

Ich versuche, das neue Android Studio zu verwenden, aber es scheint nicht richtig zu funktionieren.

Ich verwende die Gson- Bibliothek, um JSON-Objekte zu serialisieren / deserialisieren. Aber die Bibliothek ist irgendwie nicht im Build enthalten.

Ich hatte ein neues Projekt mit nur einer MainActivity erstellt . Kopierte gson-2.2.3.jar in den Ordner / libs und fügte es als Bibliotheksabhängigkeit hinzu (Rechtsklick-> Als Bibliothek hinzufügen). Dies schließt das Glas in Android Studio ein, damit es aus den Quelldateien referenziert werden kann.

Wenn ich versuche, das Projekt auszuführen, kann es nicht kompiliert werden. Deshalb habe ich hinzugefügt:

compile files('libs/gson-2.2.3.jar')

zu den Abhängigkeiten in der de .gradle-Datei. Danach wird es korrekt kompiliert, aber wenn ich die Anwendung ausführe, bekomme ich eine ClassDefNotFoundException.

Weiß jemand was ich falsch mache?

Ich habe viele Stunden mit dem gleichen Problem zu kämpfen und versucht, das Gson-Glas nicht weniger zum Laufen zu bringen. Ich habe es endlich geknackt - hier sind die Schritte, die ich unternommen habe:

1. Legen Sie das Gson-Glas (in meinem Fall gson-2.2.4.jar) in den libsOrdner
2. Klicken Sie mit der rechten Maustaste darauf und klicken Sie auf "Als Bibliothek hinzufügen".

3. Stellen Sie sicher, dass compile files('libs/gson-2.2.4.jar')sich das in Ihrer build.gradleDatei befindet (oder compile fileTree(dir: 'libs', include: '*.jar')wenn Sie viele JAR-Dateien verwenden).

   Bearbeiten: Verwenden Sie implementation files('libs/gson-2.2.4.jar')(oder implementation fileTree(dir: 'libs', include: '*.jar')) in Android Studio 3.0+

4. Führen Sie einen sauberen Build durch (Sie können dies wahrscheinlich in Android Studio gradlew cleanproblemlos tun, aber um sicherzustellen, dass ich in einem Terminal zum Stammordner meiner App navigiert und getippt habe . Unter Mac OS X kann der Befehl auf Ihrem System anders sein

Nachdem ich die obigen vier gemacht hatte, fing es an, gut zu funktionieren. Ich denke, der Schritt "Als Bibliothek hinzufügen" war der, den ich zuvor verpasst hatte, und er hat auch nicht funktioniert, bis ich ihn auch bereinigt habe.

[Bearbeiten - fügte den build.gradleSchritt hinzu, der auch notwendig ist, wie andere darauf hingewiesen haben]

Hier sind die Anweisungen zum Hinzufügen einer lokalen JAR-Datei als Bibliothek zu einem Modul:

1. Erstellen Sie einen 'libs'-Ordner in der obersten Ebene des Modulverzeichnisses (dasselbe Verzeichnis, das das' src'-Verzeichnis enthält).

   

2. Im build.gradle fileFügen Sie die folgenden , so dass Ihre Abhängigkeiten Schließung hat:

   dependencies {
       // ... other dependencies
       compile files('libs/<your jar's name here>')
   }

3. Android Studio sollte bereits einen Gradlew-Wrapper eingerichtet haben. Navigieren Sie über die Befehlszeile zur obersten Ebene Ihres Projekts (dem Verzeichnis mit einer gradlewDatei).

   Ausführen ./gradlew assemble. Dies sollte das Projekt mit der Bibliothek kompilieren. Möglicherweise müssen Sie Fehler in Ihrer build.gradle-Datei nach Bedarf beheben.

4. Damit Android Studio die lokalen JAR-Dateien als Bibliotheken zur Unterstützung beim Codieren in der IDE erkennt, müssen Sie einige weitere Schritte ausführen:

   4.1. Klicken Sie mit der rechten Maustaste auf das Modul im linken Bereich und wählen Sie Open Library Settings.

   

   4.2. Wählen Sie im linken Bereich des Dialogfelds Libraries.

   4.3. Klicken Sie auf das +Zeichen über dem Bedienfeld als zweites von links ->Java

   

   4.4. Wählen Sie Ihr lokales Glas aus und fügen Sie es dem Projekt hinzu.

5. Möglicherweise müssen Sie den obigen ./gradlewBefehl noch einmal ausführen

Klicken Sie im Projekt mit der rechten Maustaste

-> new -> module
-> import jar/AAR package
-> import select the jar file to import
-> click ok -> done

Befolgen Sie die folgenden Screenshots:

1:

2:

3:

Sie werden dies sehen:

In Android Stuido verwende ich gerne Gradle, um die Gson-Bibliothek zu verwalten.

Fügen Sie die folgende Abhängigkeit in Ihre build.gradle-Datei ein.

repositories {mavenCentral()}

dependencies {compile 'com.google.code.gson:gson:2.2.4'}

Alles ist ok.

Sie können diesen Beitrag auch sehen. Der beste Weg, um Bibliotheken von Drittanbietern in Android Studio zu integrieren

IIRC, die einfache Verwendung von "Als Bibliothek hinzufügen" reicht nicht aus, um mit dem Projekt kompiliert zu werden.

Überprüfen Sie Intellij Hilfe über Bibliotheken zu einem Projekt hinzufügen

Der Teil, der Sie am meisten interessieren sollte, ist folgender:

(In File > Project Structure) Öffnen Sie die Moduleinstellungen und wählen Sie die Registerkarte Abhängigkeiten.

Klicken Sie auf der Registerkarte Abhängigkeiten auf Hinzufügen und wählen Sie Bibliothek aus.

Wählen Sie im Dialogfeld "Bibliotheken auswählen" eine oder mehrere Bibliotheken aus und klicken Sie auf "Ausgewählte hinzufügen".

Wenn die Bibliothek nicht im Dialogfeld angezeigt wird, fügen Sie sie in den Bibliothekseinstellungen direkt unter Module hinzu.

Sie sollten nicht compile files()mehr hinzufügen müssen , und die Bibliothek sollte ordnungsgemäß zu Ihrem Projekt hinzugefügt werden.

Alle diese Lösungen sind veraltet. In Android Studio ist das jetzt ganz einfach:

Datei> Neues Modul ...

Der nächste Bildschirm sieht seltsam aus, als würden Sie ein Widget oder etwas anderes auswählen, aber lassen Sie es auf dem ersten Bild und scrollen Sie unten und suchen Sie "JAR- oder .AAR-Paket importieren".

Nehmen Sie dann Project Structureaus dem Menü Datei. Wählen Sie appaus dem geöffneten Fenster, wählen Sie dependencies, drücken Sie green plus button, wählen Sie module dependencydann das importierte Modul aus und drücken SieOK

Einfache Schritte zum Hinzufügen einer externen Bibliothek in Android Studio

1. Wenn Sie in sind Android - Ansicht in Projekt - Explorer, ändern Sie auf Projektansicht wie unten

2. Klicken Sie mit der rechten Maustaste auf das gewünschte Modul, in dem Sie die externe Bibliothek hinzufügen möchten, und wählen Sie dann aus Neu> Directroy und nennen Sie es ' libs '.
3. Kopieren Sie nun die Datei blah_blah.jar in den Ordner ' libs '
4. Klicken Sie mit der rechten Maustaste auf die Datei blah_blah.jar und wählen Sie dann ' Als Bibliothek ". Dadurch werden automatisch Build.gradle als Kompilierungsdateien ('libs / blah_blah.jar') hinzugefügt und eingegeben und der Gradle synchronisiert. Und du bist fertig

Bitte beachten Sie: Wenn Sie Bibliotheken von Drittanbietern verwenden, ist es besser, Abhängigkeiten zu verwenden, bei denen das Gradle-Skript die JAR und die Abhängigkeits-JAR automatisch herunterlädt, wenn das Gradle-Skript ausgeführt wird.

Beispiel: Kompilieren Sie 'com.google.android.gms: play-services-ads: 9.4.0'.

Lesen Sie mehr über Gradle Dependency Mangement

'Dateien kompilieren ...' funktionierte früher für mich, aber nicht mehr. Nach vielen Schmerzen stellte ich fest, dass dies stattdessen funktioniert:

compile fileTree(dir: 'libs', include: '*.jar')

Ich habe keine Ahnung, warum das einen Unterschied gemacht hat, aber zumindest funktioniert das verdammte Ding jetzt.

1. Laden Sie die Bibliotheksdatei von der Website herunter
2. Kopieren aus Windows erkunden
3. Einfügen in den lib-Ordner aus dem Projektexplorer
4. Ctrl+ Alt+ Shift+ SProjektstruktur öffnen
5. Wählen Sie die Registerkarte Abhängigkeiten und fügen Sie die Datei mit + hinzu
6. Symbolleiste Synchronisieren Sie das Projekt mit der Gradle-Datei mithilfe der Schaltfläche

Das hat mein Problem gelöst. Versuchen Sie, wenn jemand mehr Details möchte, lassen Sie es mich wissen.

Ich habe es geschafft, indem ich nur eine Zeile hinzugefügt habe zu build.gradle:

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar']) ----> AS creates this
    implementation 'com.google.code.gson:gson:2.3.1'   ----------> I added this one
}

Vergessen Sie nicht zu klicken Sync now in die obere rechte Ecke .

Ich benutze Android Studio 1.0.1.

Ich fand Dependency Manager von Android Studio sehr praktisch und leistungsstark für die Verwaltung von Abhängigkeiten von Drittanbietern (wie hier erwähnt). Bereitstellung einer Schritt-für-Schritt-Anleitung, die für mich funktioniert hat (HINWEIS: Diese Schritte wurden für Android Studio 1.6 und höhere Versionen auf der Windows-Plattform getestet).

Schritt 1: Gehen Sie zu "Erstellen> Bibliotheken und Abhängigkeiten bearbeiten ...", um den Dialog "Projektstruktur" zu öffnen.

Schritt 2: Wählen Sie "App" und dann die Registerkarte "Abhängigkeiten". Wählen Sie dann "Hinzufügen> 1 Bibliotheksabhängigkeit".

Schritt 3: Das Dialogfeld "Bibliotheksabhängigkeit auswählen" wird angezeigt. Geben Sie bei der Suche "gson" an und klicken Sie auf die Schaltfläche "Suchen".

Schritt 4: Die gewünschte Abhängigkeit wird in der Suchliste angezeigt. Wählen Sie com.google.code.gson: gson: 2.7 (dies ist die neueste Version zu dem Zeitpunkt, als ich die Antwort geschrieben habe) und drücken Sie OK

Drücken Sie im Dialogfeld "Projektstruktur" auf OK. Gradle würde Ihre Build-Skripte entsprechend aktualisieren.

Hoffe das würde helfen :)

1. Legen Sie das Glas (in meinem Fall gson-2.2.4.jar) in den Ordner libs.

2. Stellen Sie sicher, dass sich compile files ( libs/gson-2.2.4.jar) in Ihrer build.gradle-Datei befindet.

3. Klicken Sie nun auf "Projekt mit Gradle-Dateien synchronisieren" (links zum AVD-Manager in der oberen Leiste).

Nachdem ich die obigen drei gemacht hatte, fing es an, gut zu funktionieren.

Laden Sie Ihre .jarDatei herunter und kopieren Sie sie in einen libsOrdner. Fügen Sie dann diese Zeile zu build.gradle hinzu:

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation 'com.google.code.gson:gson:2.3.1'
}

Vergessen Sie nicht, auf "Jetzt synchronisieren" zu klicken.

Sie können dies mit zwei Optionen tun.

erster einfacher Weg.

Kopieren Sie die JAR-Datei in die Zwischenablage und fügen Sie sie dem Ordner libs hinzu. Um den libs-Ordner im Projekt anzuzeigen, wählen Sie das Projekt in der Combobox über den Ordnern aus.

Klicken Sie dann mit der rechten Maustaste auf die JAR-Datei und klicken Sie auf Als Bibliothek hinzufügen. Wählen Sie dann ein Modul aus und klicken Sie auf OK. Sie können die JAR-Datei in der Datei build.gradle im Abhängigkeitsblock sehen.

 dependencies {
        implementation fileTree(dir: 'libs', include: ['*.jar'])
        implementation 'com.android.support:appcompat-v7:21.0.3'
        implementation project(':okhttp-2.0.0')
        implementation 'com.google.code.gson:gson:2.3.1'
    }

Der zweite Weg ist folgender: Wir können einem Modul eine JAR-Datei hinzufügen, indem wir diese JAR-Datei als JAR-Modul importieren und dieses Modul dann einem beliebigen Modul hinzufügen.

Importmodul ---> Wählen Sie Ihre .jar-Datei -> als Import als .jar -

Dann STRG + ALT + UMSCHALT + S -> Projektstruktur -> Wählen Sie das gewünschte Modul aus, um ein Glas hinzuzufügen -> Abhängigkeiten -> Modulabhängigkeit. build.gradle des Moduls wird automatisch aktualisiert.

Ich habe über 3 Schritte und seinen Arbeitszauber für mich getan.

(Ich benutze Android Studio 2.1.2)

Schritt 1

• Fügen Sie den Namen Ihres JAR-Pakets (als Beispiel compile 'com.squareup.okhttp3:okhttp:3.3.1') in das Gradle-Build-Skript unter build.gradle (Modul: App) ein .

Schritt 2: Klicken Sie mit der rechten Maustaste auf den App- Ordner -> Neu -> Modul

Schritt 3: Klicken Sie auf JAR / .AAR-Paket importieren und durchsuchen Sie dann Ihr Paket. als Beispiel: OkHttp.jar

Mit Android Studio 3+:

Sie sollten einfach in der Lage sein, die JAR-Datei einfach in den libs-Ordner direkt unter dem App-Ordner zu kopieren.

... myproject \ app \ libs \ myfile.jar

Wählen Sie dann Projektdateien aus der Dropdown-Liste im Projektfenster aus, klicken Sie mit der rechten Maustaste auf das Projekt und wählen Sie Synchronisieren, um die Datei in Projektdateien anzuzeigen. Die Abhängigkeiten werden automatisch in die Gradle-Datei (Modul: App) eingefügt.

dependencies {
...
    implementation files('libs/myfile.jar')

Hier ist eine andere Lösung:

Wechseln Sie zur Ansicht Projektdateien (wählen Sie Projektdateien aus der Dropdown-Liste aus).

Wählen Sie Neu ... Verzeichnis und erstellen Sie einen Ordner mit dem Namen libs direkt unter der App.

Öffnen Sie den Datei-Explorer, kopieren Sie Ihre JAR-Datei und fügen Sie sie in den Ordner libs ein.

Klicken Sie in Android Studio mit der rechten Maustaste auf die JAR-Datei und wählen Sie im Popup-Menü die Option Als Bibliothek hinzufügen ... aus.

Sie sollten die Datei in der Abhängigkeitsliste in der Gradle-Datei sehen:

dependencies {
...
    implementation files('libs/myfile.jar')
}

Öffnen Sie Ihre Java-Datei und fügen Sie dort die Importanweisung hinzu:

import com.xxx.xxx;

Legen Sie die .jarDateien im libsOrdner des Android-Projekts ab.

Fügen Sie dann diese Codezeile in die Gradle-Datei der App ein:

    compile fileTree(dir: 'libs', include: ['*.jar'])

Für Android Gradle Plugin 3.0 und höher ist es besser, dies stattdessen zu verwenden:

    implementation fileTree(dir: 'libs', include: ['*.jar'])

Im Gegensatz zu Eclipse müssen wir jar nicht herunterladen und in den Ordner / libs legen. Gradle erledigt diese Dinge, wir müssen nur Gradle-Abhängigkeiten hinzufügen, Gradle lädt sie herunter und legt sie im Gradle-Cache ab.

Wir müssen Abhängigkeiten hinzufügen als:

Abhängigkeiten {Implementierung 'com.google.code.gson: gson: 2.2.4'}

Das ist es. Wir können jedoch auch jar herunterladen und als Bibliothek hinzufügen. Die beste Vorgehensweise ist jedoch, Gradle-Abhängigkeiten hinzuzufügen.

menu File -> project struct -> module select "app" -> dependencies tab -> + button 
-> File dependency -> PATH/myfile.jar

Schritt 1: Jetzt app foldersollten Sie unter Ihrem sehen libs, wenn Sie es nicht sehen, dann erstellen Sie es .

Schritt 2: Drag & Drop the .jar file hereMöglicherweise erhalten Sie eine Eingabeaufforderung "This file does not belong to the project". Klicken Sie einfach auf die OKSchaltfläche.

Schritt 3: Jetzt sollten Sie die JAR-Datei im Ordner libs sehen , mit der rechten Maustaste auf die JAR-Datei klicken und auswählen"Add as library", Click OK for prompt "Create Library"

Schritt 4: Jetzt wurde dieses Glas hinzugefügt.

Erstellen Sie eine Ordnerbibliothek. Fügen Sie Ihre JAR-Datei hinzu. Klicken Sie mit der rechten Maustaste darauf und Sie finden add jar als Abhängigkeit. Klick es an. Es ist alles was Sie tun müssen. Sie finden die Abhängigkeiten, die Ihrer build.gradle-Datei hinzugefügt wurden.

1) Erstellen Sie einen Ordner 'your_libs' im Ordner Project / app / src.

2) Kopieren Sie Ihre JAR-Datei in diesen Ordner 'your_libs'

3) Gehen Sie in Android Studio zu Datei -> Projektstruktur -> Abhängigkeiten -> Hinzufügen -> Dateiabhängigkeit und navigieren Sie zu Ihrer JAR-Datei, die sich unter 'src / your_libs' befinden sollte.

3) Wählen Sie Ihre JAR-Datei aus und klicken Sie auf "OK".

und dann können Sie auf Ihrem build.gradle Folgendes sehen: compile files ('src / your_libs / your.jar')

In Android Studio 1.1.0. Ich habe diese Frage mit folgenden Schritten gelöst:

1: Legen Sie die JAR-Datei in das libs-Verzeichnis. (im Finder)

2: Öffnen Sie die Moduleinstellungen, gehen Sie zu Abhängigkeiten. In der linken unteren Ecke befindet sich eine Plus-Schaltfläche. Klicken Sie auf die Plus-Schaltfläche und wählen Sie "Dateiabhängigkeit". Hier sehen Sie Ihre JAR-Datei. Wählen Sie es aus und es ist gelöst.

Ich habe alle Antworten hier gelesen und sie scheinen alle alte Versionen von Android Studio abzudecken!

Bei einem mit Android Studio 2.2.3 erstellten Projekt musste ich nur ein libsVerzeichnis unter erstellenapp und mein Glas dort platzieren. Ich habe das mit meinem Dateimanager gemacht, ohne in Android Studio etwas anklicken oder bearbeiten zu müssen.

Warum funktioniert es? Öffnen Sie Build / Edit Libraries and Dependencies und Sie werden sehen:

{include=[*.jar], dir=libs}

Unter Mac OS X:

1. Jar als Bibliothek hinzufügen (jar in libs ziehen, Rechtsklick als lib hinzufügen)

2. Kompilierungsanweisung hinzufügen zu build.grade

3. Installieren gradle v1.6(Homebrew verwenden)

   • Gebräu installieren Gradle
   • gradle -v
   • Wenn nicht v1.6, aktualisieren Sie Homebrew

4. gradle sauber (Android neu bauen hat nicht funktioniert)

Das hat mich geklärt.

Wie viele zuvor darauf hingewiesen haben, werden Sie hinzufügen

compile files('libs/gson-2.2.3.jar') 

in Ihre build.gradle-Datei.

Ich habe jedoch ein Projekt in Android Studio, das von Eclipse migriert wurde. In diesem Fall heißt der Ordner "libs" "lib", sodass das Entfernen des "s" für mich das Problem löste.

1. Der libsOrdner wurde auf der Ebene von hinzugefügt app.
2. Alle jarsin diesem Projekt hinzugefügt .
3. Wählen Sie als Nächstes alle Gläser im libsOrdner aus.
4. Klicken Sie mit der rechten Maustaste auf die ausgewählten Elemente und sagen Sie add library
5. Dann finden Sie die Erweiterungsoption für Jars im Projektexplorer.

Ich habe beobachtet, CTRL+ ALT+ SHIFT+ S-> Projektstruktur -> App-Modul -> Abhängigkeiten "hatte anfangs bereits einen Eintrag wie (dir: 'libs', include: '*.jar')unter compile-option. Und nach dem Hinzufügen der JARs gemäß den oben angegebenen Schritten wurden build.gradledie Einträge für das neu hinzugefügte erhalten Glas selbst.

In Android Studio 2.1 folge ich diesem Weg:

Gehe zu App -> src-> main -> Assets- Ordner (falls nicht verfügbar, erstelle sie) -> lege deine JAR-Dateien ab

Fügen Sie in Ihrem build.gradle eine Abhängigkeit wie folgt hinzu:

implementation files('src/main/assets/jsoup.jar')
implementation files('src/main/assets/org-apache-xmlrpc.jar')
implementation files('src/main/assets/org.apache.commons.httpclient.jar')
implementation files('src/main/assets/ws-commons-util-1.0.2.jar')

Jetzt synchronisieren. Jetzt sind Ihre JAR-Dateien einsatzbereit.

Für neuere Android 1.0.2 ist Folgendes bereits in Ihrer build.gradle-Datei enthalten

implementation fileTree(include: ['*.jar'], dir: 'libs')

Fügen Sie das Bibliotheksglas zu Ihrem libs-Ordner hinzu -> klicken Sie mit der rechten Maustaste auf die Bibliothek -> klicken Sie auf Als Bibliothek hinzufügen -> Sie werden aufgefordert, das Projekt hinzuzufügen -> wählen Sie Ihr Projekt aus -> klicken Sie auf OK. Die folgende Zeile wird automatisch zum Erstellen hinzugefügt .gradle

implementation files('libs/android-query.jar')

Das hat es für mich getan. es war nichts mehr erforderlich. Ich habe dies für Android Aquery eine andere Drittanbieter-Bibliothek für Android gezeigt.

Meine Antwort besteht im Wesentlichen darin, einige der richtigen, aber unvollständigen Antworten zu sammeln, die oben angegeben wurden.

1. Öffnen Sie build.gradle

2. Fügen Sie Folgendes hinzu:

   dependencies {
   compile 'com.android.support:appcompat-v7:19.+'
   compile fileTree(dir: 'libs', include: ['*.jar'])
   compile 'com.google.code.gson:gson:2.3'
   }

   Dies ermöglicht die Unterstützung von zwei verschiedenen Möglichkeiten zum Hinzufügen von Abhängigkeiten. Das compile fileTree(dir: 'libs', include: ['*.jar'])(wie @Binod erwähnt) weist den Compiler an, unter den Ordnerbibliotheken nach JEDEM JAR zu suchen. Es wird empfohlen, einen solchen Ordner 'libs' zu erstellen, der die JAR-Pakete enthält, die unsere Anwendung verwenden muss.

Dies ermöglicht jedoch auch die Unterstützung der Maven-Abhängigkeit. Die Kompilierung 'com.google.code.gson:gson:2.3'(wie von @saneryee erwähnt) ist eine weitere empfohlene Methode, um Abhängigkeiten hinzuzufügen, die sich in einem zentralen Remote-Repository und nicht in unserem "lokalen Repository" / libs befinden. Grundsätzlich wird gradle angewiesen, nach dieser Version dieses Pakets zu suchen, und der Compiler wird angewiesen, dies beim Kompilieren des Projekts zu berücksichtigen (im Klassenpfad).

PS: Ich benutze beide