¿Cómo exportar la biblioteca a Jar en Android Studio?

84

He descargado algunas fuentes de la biblioteca y me gustaría exportarlas como un archivo Jar usando Android Studio. ¿Hay alguna forma de exportar a un archivo jar usando Android Studio?

editar:

La biblioteca que quiero exportar como jar es una biblioteca de Android. Se llama "StandOut" y se puede descargar desde GitHub. https://github.com/pingpongboss/StandOut

android  android-studio 
— Pourpre de salvia
fuente
— Proporcione
Edité mi pregunta con los detalles de la biblioteca de Android.
— Sage Pourpre

Respuestas:

85

No es posible exportar una biblioteca de Android como un archivo jar. Sin embargo, es posible exportarlo como aararchivo. Aararchivos que son el nuevo formato binario para las bibliotecas de Android. Hay información sobre ellos en Google I / O, el video de New Build System .

Primero, cree la biblioteca en Android Studio o desde la línea de comandos que se emite gradle builddesde el directorio raíz de su biblioteca.

Esto resultará en <yourlibroot>/libs/build/yourlib.aarfile.

Este archivo aar es una representación binaria de su biblioteca y se puede agregar a su proyecto en lugar de la biblioteca como un proyecto de dependencia.

Para agregar el archivo aar como una dependencia, debe publicarlo en el maven central o en su repositorio local de maven, y luego hacer referencia al archivo aar en el archivo de su proyecto gradle.build.

Sin embargo, este paso es un poco complicado. He encontrado una buena explicación de cómo hacerlo aquí:

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

— Alexander Kulyakhtin
fuente
2
También tener una biblioteca de Android dependiendo de otra biblioteca de Android puede romper las cosas.
— Loïc Faure-Lacroix
¿La carpeta res se incluirá en el archivo aar?
— Bagusflyer
vea la respuesta de @ Wallmart_Hobo a continuación, es posible y puedo confirmar que el jar exportado funciona bien en un proyecto de aplicación de Android eclipse.
— Pellet
2
Encontré mi archivo aar incluido en este enlace: lib \ build \ outputs \ aar
— Simon
— TeeTracker
44

Pude crear un código fuente de biblioteca para un .jararchivo compilado , utilizando el enfoque de esta solución: https://stackoverflow.com/a/19037807/1002054

Aquí está el desglose de lo que hice:

1. Repositorio de la biblioteca de Checkout

En caso de que fuera una biblioteca de Volley

2. Importar biblioteca en Android Studio.

Usé Android Studio 0.3.7. Encontré algunos problemas durante ese paso, es decir, tuve que copiar la gradlecarpeta del nuevo proyecto de Android antes de poder importar el código fuente de la biblioteca Volley, esto puede variar según el código fuente que use.

3. Modifica tu build.gradlearchivo

// 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. Ejecute el gradlew makeJarcomando desde la raíz de su proyecto.

Yo mi caso tuve que copiar gradlew.baty gradlearchivos de nuevo proyecto androide en mi raíz del proyecto de la biblioteca. Debería encontrar su archivo de biblioteca compilado myCompiledLibrary.jaren el build\libsdirectorio.

Espero que alguien lo encuentre útil.

Editar:

Consideración

Aunque esto funciona, encontrará una excepción de biblioteca duplicada al compilar un proyecto con varios módulos, donde más de un módulo (incluido el módulo de aplicación) depende del mismo jararchivo (por ejemplo, los módulos tienen su propio directorio de biblioteca, al que se hace referencia en build.gradleun módulo dado) .

En caso de que necesite usar una biblioteca única en más de un módulo, recomendaría usar este enfoque: compilación de Android gradle y la biblioteca de soporte

— 7hny
fuente
Descubrí que no hay forma de incluir la resolución dentro del frasco. ¿Es eso posible?
— Bagusflyer
7
En versiones recientes de Android Studio requiere un cambio: la línea debe leer `from ('build / intermediates / bundles / release /')`
— Greg Ennis
@GregEnnis ya, pero en mi caso está creando un frasco con mi nombre de mobule y el frasco real se encuentra dentro de ese frasco. Extraje el jar creado con el nombre de mi módulo como module_name.jar.
— pyus13
6
@bagusflyer, si quieres una rescarpeta, un archivo AAR es exactamente eso: un archivo JAR con ressoporte para carpetas.
— Martin Konecny
¿Cómo aplicar proguard para generar este frasco?
— Amrut Bidri
37

Desde Android Studio V1.0, el archivo jar está disponible dentro del siguiente enlace del proyecto:

ver de depuración: "your_app" \ build \ intermediates \ bundles \ debug \ classes.jar

versión de lanzamiento: "your_app" \ build \ intermediates \ bundles \ release \ classes.jar

El archivo JAR se crea en el procedimiento de compilación, en la GUI de Android Studio es de Build-> Make Project y de la línea CMD es "gradlew build".

— Avi Levin
fuente
3
recibirás todos mis internets para esta respuesta
— m02ph3u5
1
Encontrado, en Build Variants, tenemos que elegir Build Variant para ser 'lanzamiento'. ¡Pero ahora classes.jar no está presente en la carpeta de lanzamiento!
— Aparajith Sairam
1
@AparajithSairam ¿cómo construiste tu JAR, línea de comando o interfaz gráfica de usuario?
— Avi Levin
1
@AparajithSairam, encontré algo en la GUI pero es relevante solo para las compilaciones de archivos APK. después de seleccionar la variante de construcción relevante, presione el ícono verde "reproducir". ejecutará un comando gradle de ensamblaje en segundo plano que creará el archivo. Para un archivo JAR en CMD, tendrá que ejecutar gradlew assembleDebug o Release o cualquier versión que tenga. Después de eso, el JAR estaría disponible en la siguiente ubicación: your_app "\ build \ intermediates \ bundles \" falvor "\ classes.jar puede ver todos sus comandos de ensamblaje usando" tareas gradlew "
— Avi Levin
1
Voté otra respuesta hace más de un año. Al diablo con ese negocio. ¡Esto es pastel! ¡¡Gracias!!
— Kevin
31

Incluya lo siguiente en 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'
    }
}

Luego puede ejecutar gradle con: ./gradlew clean javadocRelease jarReleaseque construirá su Jar y también un jar javadoc en la build/libs/carpeta.

EDITAR: Con las herramientas de Android Gradle 1.10. +, Obtener el directorio SDK de Android es diferente que antes. Tienes que cambiar lo siguiente (¡gracias Vishal!):

android.sdkDirectory

en vez de

android.plugin.sdkDirectory
— Andrey
fuente
Gran respuesta, esto funcionó perfectamente para mí. También puede agregar un objetivo gradle en Android Studio para ejecutar la tarea jarDebug que creará el jar utilizable (lo he probado en un proyecto de eclipse y también funciona bien).
— Pellet
8
¿Por qué el "nuevo" sistema de compilación de Android lo hace tan feo :(.
— Martin Konecny
Hasta ahora, esa es la única respuesta que funcionó. Muchas gracias @Walmart_Hobo
— Drew
¡Gran solución para generar un archivo JAR! ¿Es posible incluir también los recursos?
— Gaëtan
12

Pude exportar un archivo jar en Android Studio usando este tutorial: https://www.youtube.com/watch?v=1i4I-Nph-Cw "Cómo exportar Jar desde Android Studio"

Actualicé mi respuesta para incluir todos los pasos para exportar un JAR en Android Studio:

1) Cree un proyecto de aplicación de Android, vaya a app-> build.gradle

2) Cambie lo siguiente en este archivo:

  • modificar aplicar complemento: 'com.android.application' para aplicar el complemento: 'com.android.library'

  • elimine lo siguiente: applicationId, versionCode y versionName

  • Agrega el siguiente código:

// 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) No olvide hacer clic en sincronizar ahora en este archivo (arriba a la derecha o use el botón de sincronización).

4) Haga clic en la pestaña Gradle (generalmente en el medio a la derecha) y desplácese hacia abajo para exportjar

5) Una vez que vea el mensaje de compilación exitosa en la ventana de ejecución, usando el explorador de archivos normal, vaya al archivo jar exportado usando la ruta: C: \ Users \ name \ AndroidStudioProjects \ ProjectName \ app \ release , debería ver en este directorio su archivo jar.

Buena suerte :)

— RMDev
fuente
1
El paso 2 es fundamental. Nadie más menciona esto. ¡Gracias, esto funcionó para mí!
— pookie
9

Aquí hay otra respuesta ligeramente diferente con algunas mejoras.

Este código saca el .jar directamente del .aar. Personalmente, eso me da un poco más de confianza en que los bits que se envían a través de .jar son los mismos que los que se envían a través de .aar. Esto también significa que si está utilizando ProGuard, el jar de salida se ofuscará como se desee.

También agregué una tarea super "makeJar", que hace jarras para todas las variantes de compilación.

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

Para el lector curioso, luché para determinar las variables y parámetros correctos que usa el complemento com.android.library para nombrar archivos .aar. Finalmente los encontré en el Proyecto de código abierto de Android aquí .

— David
fuente
4

Podemos exportar un archivo jar para un proyecto de biblioteca de Android sin archivos de recursos de Android Studio. También es requisito lo que conocí recientemente.

1. Configura tu archivo 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. Ejecute gradlew makeJar en la raíz de su proyecto

Verá sus bibliotecas en dir como build / libs / si tiene suerte.

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

Si encontró el problema como "Excepción de tiempo de espera de socket" en la línea de comando como se muestra a continuación,

ingrese la descripción de la imagen aquí

Puede seguir estos pasos para abrir la ventana de Gradle en la parte derecha y hacer clic en "makeJar" en un estudio de Android como este,

ingrese la descripción de la imagen aquí

ingrese la descripción de la imagen aquí

Luego vaya a build / libs dir, verá su archivo jar.

Espero que te sea de ayuda.

Buena suerte @.@

Luna

— Luna Kong
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.