Come esportare la libreria in Jar in Android Studio?

84

Ho scaricato alcune fonti di libreria e vorrei esportarlo come file Jar utilizzando Android Studio. C'è un modo per esportare in file jar utilizzando Android Studio?

modificare:

La libreria che voglio esportare come jar è una libreria Android. Si chiama "StandOut" e può essere scaricato da GitHub. https://github.com/pingpongboss/StandOut

android  android-studio 
— Sage Pourpre
fonte
Si prega di fornire maggiori dettagli sulla libreria che si desidera esportare
— gamag
Ho modificato la mia domanda con i dettagli della libreria Android.
— Sage Pourpre

Risposte:

85

Non è possibile esportare una libreria Android come file jar. È possibile, tuttavia, esportarlo come aarfile. Aari file sono il nuovo formato binario per le librerie Android. Ci sono informazioni su di loro in Google I / O, il video New Build System .

Innanzitutto, crea la libreria in Android Studio o dalla riga di comando emessa gradle builddalla directory principale della libreria.

Questo risulterà in <yourlibroot>/libs/build/yourlib.aarfile.

Questo file aar è una rappresentazione binaria della tua libreria e può essere aggiunto al tuo progetto invece che alla libreria come progetto di dipendenza.

Per aggiungere un file aar come dipendenza devi pubblicarlo su Maven Central o nel tuo repository Maven locale, quindi fare riferimento al file AAR nel file del tuo progetto gradle.build.

Tuttavia, questo passaggio è un po 'complicato. Ho trovato una buona spiegazione su come farlo qui:

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

— Alexander Kulyakhtin
fonte
2
anche avere una libreria Android a seconda di un'altra libreria Android potrebbe rompere le cose.
— Loïc Faure-Lacroix
La cartella res sarà inclusa nel file aar?
— Bagusflyer
vedi la risposta di @ Wallmart_Hobo di seguito, è possibile e posso confermare che il jar esportato funziona bene in un progetto di app Android Eclipse.
— Pellet
2
Ho trovato il mio file aar incluso in questo link: lib \ build \ output \ aar
— Simon
— TeeTracker
44

Sono stato in grado di creare un codice sorgente della libreria in un .jarfile compilato , utilizzando l'approccio di questa soluzione: https://stackoverflow.com/a/19037807/1002054

Ecco la ripartizione di quello che ho fatto:

1. Checkout archivio della libreria

In ogni caso era una biblioteca di Volley

2. Importa libreria in Android Studio.

Ho usato Android Studio 0.3.7. Ho riscontrato alcuni problemi durante quel passaggio, vale a dire ho dovuto copiare la gradlecartella dal nuovo progetto Android prima di poter importare il codice sorgente della libreria Volley, questo può variare a seconda del codice sorgente che utilizzi.

3. Modifica il tuo build.gradlefile

// 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. Eseguire il gradlew makeJarcomando dalla radice del progetto.

Nel mio caso ho dovuto copiare gradlew.bate gradlefile dal nuovo progetto Android nella radice del mio progetto di libreria. Dovresti trovare il file della libreria compilata myCompiledLibrary.jarnella build\libsdirectory.

Spero che qualcuno lo trovi utile.

Modificare:

Avvertimento

Sebbene funzioni, incontrerai un'eccezione di libreria duplicata durante la compilazione di un progetto con più moduli, in cui più di un modulo (incluso il modulo dell'applicazione) dipende dallo stesso jarfile (ad es. I moduli hanno la propria directory di libreria, a cui si fa riferimento in un build.gradledato modulo) .

Nel caso in cui sia necessario utilizzare una singola libreria in più di un modulo, ti consiglio di utilizzare questo approccio: Android gradle build e la libreria di supporto

— 7hny
fonte
Ho scoperto che non c'è modo di includere la risoluzione all'interno del barattolo. È possibile?
— Bagusflyer
7
Nelle versioni recenti di Android Studio richiede una modifica: la riga dovrebbe leggere `da ('build / intermediates / bundles / release /')`
— Greg Ennis
@GregEnnis ya, ma nel mio caso sta creando un vaso con il mio nome di cellulare e il vaso effettivo si trova all'interno di quel vaso. Ho estratto il jar creato con il nome del mio modulo come module_name.jar.
— pyus13
6
@bagusflyer, Se vuoi una rescartella, un file AAR è esattamente quello: un file JAR con ressupporto per cartelle.
— Martin Konecny
come applicare proguard per generare questo vaso?
— Amrut Bidri
37

A partire da Android Studio V1.0 il file jar è disponibile all'interno del seguente collegamento al progetto:

versione di debug: "tua_app" \ build \ intermediates \ bundles \ debug \ classes.jar

release ver: "your_app" \ build \ intermediates \ bundles \ release \ classes.jar

Il file JAR viene creato durante la procedura di compilazione, nella GUI di Android Studio è da Build-> Make Project e dalla linea CMD è "gradlew build".

— Avi Levin
fonte
3
riceverai tutto il mio Internet per questa risposta
— m02ph3u5
1
Trovato, in Build Variants, dobbiamo scegliere Build Variant per essere 'release'. Ma ora il classes.jar non è presente nella cartella di rilascio!
— Aparajith Sairam
1
@AparajithSairam come hai costruito il tuo JAR, riga di comando o interfaccia grafica?
— Avi Levin
1
@AparajithSairam, ho trovato qualcosa nella GUI ma è rilevante solo per le build di file APK. dopo aver selezionato la variante build pertinente, premere l'icona verde "play". eseguirà un comando gradle dell'assieme in background che creerà il file. Per un file JAR in CMD, dovrai eseguire gradlew assembleDebug o Release o qualsiasi altra versione tu abbia. Dopodiché il JAR sarà disponibile nella seguente posizione: your_app "\ build \ intermediates \ bundles \" falvor "\ classes.jar puoi vedere tutti i tuoi comandi di assembly usando" gradlew tasks "
— Avi Levin
1
Ho votato positivamente un'altra risposta più di un anno fa. Fanculo quella faccenda. Questa è la torta! Grazie!!
— Kevin
31

Includere quanto segue in build.gradle:

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'
    }
}

Puoi quindi eseguire gradle con: ./gradlew clean javadocRelease jarReleaseche costruirà il tuo Jar e anche un jar javadoc nella build/libs/cartella.

MODIFICA: con gli strumenti gradle Android 1.10. + Ottenere la directory SDK di Android è diverso da prima. Devi modificare quanto segue (grazie Vishal!):

android.sdkDirectory

invece di

android.plugin.sdkDirectory
— Andrey
fonte
Ottima risposta, questo ha funzionato perfettamente per me. Puoi anche aggiungere un obiettivo gradle in Android Studio per eseguire l'attività jarDebug che creerà il jar utilizzabile (l'ho testato in un progetto eclipse e funziona anche bene).
— Pellet
8
Perché il "nuovo" sistema di build Android lo rende così brutto :(.
— Martin Konecny
Finora questa è l'unica risposta che ha funzionato. Grazie mille @Walmart_Hobo
— Drew
Ottima soluzione per generare un file JAR! È possibile includere anche le risorse?
— Gaëtan
12

Sono stato in grado di esportare un file jar in Android Studio utilizzando questo tutorial: https://www.youtube.com/watch?v=1i4I-Nph-Cw "How To Export Jar From Android Studio"

Ho aggiornato la mia risposta per includere tutti i passaggi per esportare un JAR in Android Studio:

1) Crea il progetto dell'applicazione Android, vai su app-> build.gradle

2) Modificare quanto segue in questo file:

  • modifica applica plug-in: "com.android.application" per applicare il plug-in: "com.android.library"

  • rimuovere quanto segue: applicationId, versionCode e versionName

  • Aggiungi il codice seguente:

// 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) Non dimenticare di fare clic su sincronizza ora in questo file (in alto a destra o usa il pulsante di sincronizzazione).

4) Fare clic sulla scheda Gradle (solitamente in mezzo a destra) e scorrere verso il basso fino a exportjar

5) Una volta visualizzato il messaggio di build riuscita nella finestra di esecuzione, utilizzando il normale file explorer vai al jar esportato utilizzando il percorso: C: \ Users \ name \ AndroidStudioProjects \ ProjectName \ app \ release dovresti vedere in questa directory il tuo file jar.

In bocca al lupo :)

— RMDev
fonte
1
Il passaggio 2 è fondamentale. Nessun altro lo menziona. Grazie, questo ha funzionato per me!
— pookie
9

Ecco un'altra risposta leggermente diversa con alcuni miglioramenti.

Questo codice prende il .jar direttamente dal .aar. Personalmente, questo mi dà un po 'più di fiducia che i bit spediti tramite .jar siano gli stessi di quelli spediti tramite .aar. Ciò significa anche che se stai usando ProGuard, il jar di output verrà offuscato come desiderato.

Ho anche aggiunto un super compito "makeJar", che crea barattoli per tutte le varianti di build.

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]
}

Per il lettore curioso, ho faticato a determinare le variabili ei parametri corretti che il plug-in com.android.library utilizza per denominare i file .aar. Finalmente li ho trovati nel progetto Android Open Source qui .

— David
fonte
4

Possiamo esportare un file jar per il progetto di libreria Android senza file di risorse da Android Studio. È anche requisito quello che ho incontrato di recente.

1. Configura il tuo file build.gradle

    // 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. Eseguire gradlew makeJar dalla root del progetto

Vedrai le tue librerie sotto dir come build / libs / se sei fortunato.

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

Se hai riscontrato un problema come "Eccezione timeout socket" sulla riga di comando come di seguito,

inserisci qui la descrizione dell'immagine

Puoi seguire questa procedura per aprire la finestra Gradle nella parte destra e fare clic su "makeJar" su Android Studio in questo modo,

inserisci qui la descrizione dell'immagine

inserisci qui la descrizione dell'immagine

Quindi vai a build / libs dir, vedrai il tuo file jar.

Spero che sia utile per te.

In bocca al lupo @.@

Luna

— Luna Kong
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.