Wie exportiere ich eine Bibliothek in Jar in Android Studio?

84

Ich habe einige Bibliotheksquellen heruntergeladen und möchte sie mit Android Studio als Jar-Datei exportieren. Gibt es eine Möglichkeit, mit Android Studio in eine JAR-Datei zu exportieren?

bearbeiten:

Die Bibliothek, die ich als JAR exportieren möchte, ist eine Android-Bibliothek. Es heißt "StandOut" und kann von GitHub heruntergeladen werden. https://github.com/pingpongboss/StandOut

android  android-studio 
— Salbei Pourpre
quelle
Bitte geben Sie weitere Details zu der Bibliothek, die Sie exportieren möchten
— Gamag
Ich habe meine Frage mit den Details der Android-Bibliothek bearbeitet.
— Salbei Pourpre

Antworten:

85

Es ist nicht möglich, eine Android-Bibliothek als JAR-Datei zu exportieren. Es ist jedoch möglich, es als aarDatei zu exportieren . AarDateien sind das neue Binärformat für Android-Bibliotheken. Informationen dazu finden Sie in Google I / O, dem Video zum neuen Build-System .

Erstellen Sie die Bibliothek zunächst in Android Studio oder über die Befehlszeile, die gradle buildaus dem Stammverzeichnis Ihrer Bibliothek ausgegeben wird.

Dies führt zu einer <yourlibroot>/libs/build/yourlib.aarDatei.

Diese aar-Datei ist eine binäre Darstellung Ihrer Bibliothek und kann anstelle der Bibliothek als Abhängigkeitsprojekt zu Ihrem Projekt hinzugefügt werden.

Um eine AAR-Datei als Abhängigkeit hinzuzufügen, müssen Sie sie in der Maven-Zentrale oder in Ihrem lokalen Maven-Repository veröffentlichen und dann auf die AAR-Datei in der Datei Ihres Projekts verweisen gradle.build.

Dieser Schritt ist jedoch etwas kompliziert. Ich habe hier eine gute Erklärung dafür gefunden:

http://www.flexlabs.org/2013/06/using-local-aar-android-library-packages-in-gradle-builds

— Alexander Kulyakhtin
quelle
2
Auch eine Android-Bibliothek in Abhängigkeit von einer anderen Android-Bibliothek kann zu Problemen führen.
— Loïc Faure-Lacroix
Wird der res-Ordner in die aar-Datei aufgenommen?
— Bagusflyer
Siehe @ Wallmart_Hobos Antwort unten, es ist möglich und ich kann bestätigen, dass das exportierte Glas in einem Eclipse-Android-App-Projekt einwandfrei funktioniert.
— Pellet
2
Ich fand meine aar-Datei in diesem Link enthalten: lib \ build \ output \ aar
— Simon
— TeeTracker
44

Ich konnte einen Bibliotheksquellcode für eine kompilierte .jarDatei mithilfe des Ansatzes dieser Lösung erstellen: https://stackoverflow.com/a/19037807/1002054

Hier ist die Aufschlüsselung dessen, was ich getan habe:

1. Checkout-Bibliotheks-Repository

Im Mai war es eine Volley-Bibliothek

2. Importieren Sie die Bibliothek in Android Studio.

Ich habe Android Studio 0.3.7 verwendet. Während dieses Schritts sind einige Probleme aufgetreten, nämlich, dass ich einen gradleOrdner aus einem neuen Android-Projekt kopieren musste, bevor ich den Quellcode der Volley-Bibliothek importieren konnte. Dies kann je nach verwendetem Quellcode variieren.

3. Ändern Sie Ihre build.gradleDatei

// If your module is a library project, this is needed
//to properly recognize 'android-library' plugin
buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:0.6.3'
    }
}

apply plugin: 'android-library'

android {
    compileSdkVersion 17
    buildToolsVersion = 17

    sourceSets {
        main  {
            // Here is the path to your source code
            java {
                srcDir 'src'
            }
        }
    }
}

// This is the actual solution, as in https://stackoverflow.com/a/19037807/1002054
task clearJar(type: Delete) {
    delete 'build/libs/myCompiledLibrary.jar'
}

task makeJar(type: Copy) {
    from('build/bundles/release/')
    into('build/libs/')
    include('classes.jar')
    rename ('classes.jar', 'myCompiledLibrary.jar')
}

makeJar.dependsOn(clearJar, build)

4. Führen Sie den gradlew makeJarBefehl von Ihrem Projektstamm aus.

Ich mein Fall hatte ich zu kopieren gradlew.batund gradleDateien von neuem Android - Projekt in meine Bibliothek Projektstamm. Sie sollten Ihre kompilierte Bibliotheksdatei myCompiledLibrary.jarim build\libsVerzeichnis finden.

Ich hoffe, jemand findet das nützlich.

Bearbeiten:

Vorbehalt

Obwohl dies funktioniert, treten beim Kompilieren eines Projekts mit mehreren Modulen doppelte Bibliotheksausnahmen auf, bei denen mehr als ein Modul (einschließlich Anwendungsmodul) von derselben jarDatei abhängt (z. B. haben Module ein eigenes Bibliotheksverzeichnis, auf das in einem build.gradlebestimmten Modul verwiesen wird). .

Wenn Sie eine einzelne Bibliothek in mehr als einem Modul verwenden müssen, würde ich diesen Ansatz empfehlen: Android Gradle Build und die Support-Bibliothek

— 7hny
quelle
Ich habe festgestellt, dass es keine Möglichkeit gibt, die Res in das Glas aufzunehmen. Ist das möglich?
— Bagusflyer
7
In neueren Versionen von Android Studio ist eine Änderung erforderlich: Die Zeile sollte "from" ("build / intermediates / bundles / release /") lauten
— Greg Ennis
@ GregEnnis ya, aber in meinem Fall wird ein Glas mit meinem Mobule-Namen erstellt und das eigentliche Glas liegt in diesem Glas. Ich habe das erstellte Glas mit meinem Modulnamen wie module_name.jar extrahiert.
— Pyus13
6
@bagusflyer, Wenn Sie einen resOrdner möchten , ist eine AAR-Datei genau das - eine JAR-Datei mit resOrdnerunterstützung.
— Martin Konecny
Wie wende ich Proguard an, um dieses Glas zu erzeugen?
— Amrut Bidri
37

Seit Android Studio V1.0 ist die JAR-Datei unter folgendem Projektlink verfügbar:

Debug-Version: "your_app" \ build \ intermediates \ bundles \ debug \ classes.jar

Release-Version: "your_app" \ build \ intermediates \ bundles \ release \ classes.jar

Die JAR-Datei wird während der Erstellungsprozedur erstellt. In der Android Studio-Benutzeroberfläche ist sie von Build-> Make Project und von der CMD-Zeile "gradlew build".

— Avi Levin
quelle
3
du sollst alle meine Internets für diese Antwort erhalten
— m02ph3u5
1
Gefunden, in Build-Varianten müssen wir Build-Variante als "Release" auswählen. Aber jetzt ist die classes.jar nicht im Release-Ordner vorhanden!
— Aparajith Sairam
1
@AparajithSairam Wie haben Sie Ihre JAR, Befehlszeile oder GUI erstellt?
— Avi Levin
1
@AparajithSairam, ich habe etwas in der GUI gefunden, aber es ist nur für die Erstellung von APK-Dateien relevant. Drücken Sie nach Auswahl der entsprechenden Build-Variante das grüne "Play" -Symbol. Es wird ein Hintergrundassemblierungsgradle-Befehl ausgeführt, der die Datei erstellt. Für eine JAR-Datei in CMD müssen Sie gradlew assembleDebug oder Release oder eine andere Variante ausführen. Danach wäre die JAR an folgendem Speicherort verfügbar: your_app "\ build \ intermediates \ bundles \" falvor "\ classes.jar Sie können alle Ihre Assembly-Befehle mit" gradlew task "anzeigen
— Avi Levin
1
Ich habe vor über einem Jahr eine andere Antwort positiv bewertet. Scheiß auf das Geschäft. Das ist Kuchen! Vielen Dank!!
— Kevin
31

Fügen Sie Folgendes in build.gradle ein:

android.libraryVariants.all { variant ->
    task("generate${variant.name}Javadoc", type: Javadoc) {
        description "Generates Javadoc for $variant.name."
        source = variant.javaCompile.source
        ext.androidJar = "${android.plugin.sdkDirectory}/platforms/${android.compileSdkVersion}/android.jar"
        classpath = files(variant.javaCompile.classpath.files) + files(ext.androidJar)
    }

    task("javadoc${variant.name}", type: Jar) {
        classifier = "javadoc"
        description "Bundles Javadoc into a JAR file for $variant.name."
        from tasks["generate${variant.name}Javadoc"]

    }

    task("jar${variant.name}", type: Jar) {
        description "Bundles compiled .class files into a JAR file for $variant.name."
        dependsOn variant.javaCompile
        from variant.javaCompile.destinationDir
        exclude '**/R.class', '**/R$*.class', '**/R.html', '**/R.*.html'
    }
}

Sie können dann gradle mit: ausführen, wodurch ./gradlew clean javadocRelease jarReleaseSie Ihr Jar und auch ein Javadoc-Jar in den build/libs/Ordner einbauen .

BEARBEITEN : Mit Android Gradle Tools 1.10. + Ist das Abrufen des Android SDK-Verzeichnisses anders als zuvor. Sie müssen Folgendes ändern (danke Vishal!):

android.sdkDirectory

anstatt

android.plugin.sdkDirectory
— Andrey
quelle
Tolle Antwort, das hat bei mir perfekt funktioniert. Sie können auch ein Gradle-Ziel in Android Studio hinzufügen, um die jarDebug-Task auszuführen, mit der das verwendbare jar erstellt wird (ich habe dies in einem Eclipse-Projekt getestet und es funktioniert auch einwandfrei).
— Pellet
8
Warum macht das "neue" Android-Build-System es so hässlich :(.
— Martin Konecny
Bisher ist dies die einzige Antwort, die funktioniert hat. Vielen Dank @Walmart_Hobo
— Drew
Tolle Lösung, um eine JAR-Datei zu generieren! Ist es möglich, auch die Ressourcen einzubeziehen?
— Gaëtan
12

Mit diesem Tutorial konnte ich eine JAR-Datei in Android Studio exportieren: https://www.youtube.com/watch?v=1i4I-Nph-Cw "So exportieren Sie JAR aus Android Studio"

Ich habe meine Antwort aktualisiert und alle Schritte zum Exportieren einer JAR in Android Studio aufgenommen:

1) Erstellen Sie ein Android-Anwendungsprojekt und gehen Sie zu app-> build.gradle

2) Ändern Sie Folgendes in dieser Datei:

  • Ändern Sie das Anwendungs-Plugin: 'com.android.application' , um das Plugin anzuwenden: 'com.android.library'

  • Entfernen Sie Folgendes: applicationId, versionCode und versionName

  • Fügen Sie den folgenden Code hinzu:

// Task to delete old jar
task deleteOldJar(type: Delete){
   delete 'release/AndroidPlugin2.jar'
}
// task to export contents as jar
task exportJar(type: Copy) {
    from ('build/intermediates/bundles/release/')
    into ('release/')
    include ('classes.jar')
    rename('classes.jar', 'AndroidPlugin2.jar')
}
exportJar.dependsOn(deleteOldJar, build)

3) Vergessen Sie nicht, jetzt in dieser Datei auf " Synchronisieren" zu klicken (oben rechts oder mit der Schaltfläche "Synchronisieren").

4) Klicken Sie auf die Registerkarte Gradle (normalerweise Mitte rechts) und scrollen Sie nach unten zum Exportjar

5) Sobald Sie die Meldung " Erfolgreich erstellen" im Ausführungsfenster sehen, wechseln Sie mit dem normalen Datei-Explorer zum exportierten JAR unter dem folgenden Pfad: C: \ Benutzer \ Name \ AndroidStudioProjects \ Projektname \ App \ Release. In diesem Verzeichnis sollte Ihre JAR-Datei angezeigt werden.

Viel Glück :)

— RMDev
quelle
1
Schritt 2 ist kritisch. Niemand sonst erwähnt dies. Danke, das hat bei mir funktioniert!
— Pookie
9

Hier ist noch eine andere, etwas andere Antwort mit ein paar Verbesserungen.

Dieser Code nimmt die .jar direkt aus der .aar. Persönlich gibt mir das ein bisschen mehr Vertrauen, dass die Bits, die über .jar versendet werden, die gleichen sind wie die, die über .aar versendet werden. Dies bedeutet auch, dass bei Verwendung von ProGuard das Ausgabeglas wie gewünscht verschleiert wird.

Ich habe auch eine super "makeJar" -Aufgabe hinzugefügt, die Jars für alle Build-Varianten erstellt.

task(makeJar) << {
    // Empty. We'll add dependencies for this task below
}

// Generate jar creation tasks for all build variants
android.libraryVariants.all { variant ->
    String taskName = "makeJar${variant.name.capitalize()}"

    // Create a jar by extracting it from the assembled .aar
    // This ensures that products distributed via .aar and .jar exactly the same bits
    task (taskName, type: Copy) {
        String archiveName = "${project.name}-${variant.name}"
        String outputDir = "${buildDir.getPath()}/outputs"

        dependsOn "assemble${variant.name.capitalize()}"
        from(zipTree("${outputDir}/aar/${archiveName}.aar"))
        into("${outputDir}/jar/")
        include('classes.jar')
        rename ('classes.jar', "${archiveName}-${variant.mergedFlavor.versionName}.jar")
    }

    makeJar.dependsOn tasks[taskName]
}

Für den neugierigen Leser hatte ich Mühe, die richtigen Variablen und Parameter zu ermitteln, mit denen das Plugin com.android.library .aar-Dateien benennt. Ich habe sie endlich im Android Open Source Projekt hier gefunden .

— David
quelle
4

Wir können eine JAR-Datei für ein Android-Bibliotheksprojekt ohne Ressourcendateien von Android Studio exportieren. Es ist auch Voraussetzung, was ich kürzlich getroffen habe.

1. Konfigurieren Sie Ihre build.gradle-Datei

    // Task to delete old jar

    task clearJar(type: Delete){
       delete 'release/lunademo.jar'
    }

    // task to export contents as jar
    task makeJar(type: Copy) {
       from ('build/intermediates/bundles/release/')
       into ('build/libs/')
       include ('classes.jar')
       rename('classes.jar', 'lunademo.jar')
    }
    makeJar.dependsOn(clearJar, build)

2. Führen Sie gradlew makeJar unter Ihrem Projektstamm aus

Sie werden Ihre Bibliotheken unter dir als build / libs / sehen, wenn Sie Glück haben.

================================================== ==========

Wenn Sie das Problem als "Socket-Timeout-Ausnahme" in der Befehlszeile wie folgt festgestellt haben,

Geben Sie hier die Bildbeschreibung ein

Sie können diese Schritte ausführen, um das Gradle-Fenster im rechten Teil zu öffnen und in Android Studio wie folgt auf "makeJar" zu klicken.

Geben Sie hier die Bildbeschreibung ein

Geben Sie hier die Bildbeschreibung ein

Gehen Sie dann zu build / libs dir, Sie werden Ihre JAR-Datei sehen.

Hoffe, dass es für dich hilfreich ist.

Viel Glück @.@

Luna

— Luna Kong
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.