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

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

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

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".

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

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 :)

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í .

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,

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,

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

Espero que te sea de ayuda.

Buena suerte @.@

Luna