modulos - libreria android studio

¿Cómo construir una biblioteca de Android con Android Studio y Gradle?

Question

Estoy intentando migrar un proyecto de Eclipse, pero no he probado nada que funcione. En Eclipse tengo 3 proyectos (2 proyectos de aplicaciones de Android y 1 proyecto de biblioteca de Android). Los 2 proyectos de la aplicación dependen del proyecto de la biblioteca. Cuando hago la exportación de gradle obtengo 3 proyectos que no funcionan. Estoy abierto a la reestructuración del proyecto, pero no he encontrado ninguna documentación sobre cómo debe hacerse.

¿Hay alguna manera de hacer que los 3 proyectos que exportan Eclipse funcionen juntos? ¿Es mejor reestructurar las cosas y, de ser así, la documentación de cómo se debe hacer esto?

Actualizar

He subido todo el proyecto a GitHub https://github.com/respectTheCode/android-studio-library-example

Actualización 1

Según las sugerencias de Padma Kumar esto es lo que he intentado.

1. Crea un nuevo proyecto llamado MyApp
2. Haga clic en File > New Module , elija Android Library y MyLib nombre MyLib
3. Haga clic en Build > Make Project

La construcción falla con este error

Module "MyLib" was fully rebuilt due to project configuration/dependencies changes
Compilation completed with 1 error and 0 warnings in 19 sec
1 error
0 warnings
/.../MyApp/MyLib/build/bundles/debug/AndroidManifest.xml
Gradle: <manifest> does not have package attribute.

Luego agregué un atributo de package al manifiesto que lo hacía

<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.example.mylib" >

Después de construir recibo este error

Module "MyApp" was fully rebuilt due to project configuration/dependencies changes
Compilation completed with 2 errors and 0 warnings in 13 sec
2 errors
0 warnings
/.../MyApp/MyLib/src/main/java/com/example/mylib/MainActivity.java
Gradle: package R does not exist
Gradle: package R does not exist

Agregar dependencia no parece tener ningún impacto en el error. Continuando desde arriba

1. Haga clic en File > Project Structure > Modules > MyApp-MyApp
2. Cambiar a la pestaña de Dependencies
3. Haga clic en + > Module Dependency y seleccione MyLib
4. Haga clic en Apply y OK
5. Haga clic en Build > Make Project

Actualización 2

Según las sugerencias de Ethan, aquí es donde obtenemos

El 2 sub proyecto build.gradle parece tener todas las partes correctas y la única diferencia es que la siguiente línea de plugin es MyApp/build.gradle .

buildscript {
    repositories {
        maven { url ''http://repo1.maven.org/maven2'' }
    }
    dependencies {
        classpath ''com.android.tools.build:gradle:0.4''
    }
}
apply plugin: ''android''

dependencies {
    compile files(''libs/android-support-v4.jar'')
}

android {
    compileSdkVersion 17
    buildToolsVersion "17.0.0"

    defaultConfig {
        minSdkVersion 7
        targetSdkVersion 16
    }
}

El proyecto raíz build.gradle estaba vacío, así que agregué los dos proyectos como este

dependencies {
    compile project(":MyLib")
    compile project(":MyApp")
}

Ahora obtengo este error al construir

Gradle:
FAILURE: Build failed with an exception.
* Where:
Build file ''/Users/kevin/GitHub/AppPress/MyApp/build.gradle'' line: 2
* What went wrong:
A problem occurred evaluating root project ''MyApp''.
> Could not find method compile() for arguments [project '':MyLib''] on root project ''MyApp''.
* Try:
Run with --stacktrace option to get the stack trace. Run with --info or --debug option to get more log output.

Actualización 3

Muchas gracias Ethan por resolver esto.

1. Agregue el compile project('':SubProjects:MyLib'') a MyLib/build.gradle
2. Eliminar compile files(''libs/android-support-v4.jar'') desde MyLib/build.gradle
3. Cierre el proyecto e importe el proyecto raíz desde Gradle

Actualización 4

A partir de 0.1.2 ahora puede incluir compile "com.android.support:support-v4:13.0.0" lugar de compile files(''libs/android-support-v4.jar'') . Como viene de mavin ahora, puede incluir esto en múltiples proyectos sin problemas.

buildscript {
    repositories {
        mavenCentral()
    }

    dependencies {
        classpath ''com.android.tools.build:gradle:0.4.2''
    }
}

apply plugin: ''android''

dependencies {
    compile "com.android.support:support-v4:13.0.0"

    compile project('':SubProjects:MyLib'')
}

Actualización 5

A partir de 0.1.3, ahora hay un botón "Proyecto de sincronización" en la barra de herramientas. Puede hacer clic en eso en lugar de .gradle a importar su proyecto después de realizar cambios en los archivos .gradle .

Answer 1

Gradle Build Tools 2.2.0+ - Todo funciona

Esta es la forma correcta de hacerlo

Al tratar de evitar experimental y francamente harto del NDK y de todos sus hackers, me complace que salió 2.2.x de Gradle Build Tools y ahora simplemente funciona. La clave es el argumento ndkBuild ruta ndkBuild en un Android.mk o cambiar ndkBuild por cmake y apuntar el argumento de ruta en un CMakeLists.txt construcción CMakeLists.txt .

android {
    compileSdkVersion 19
    buildToolsVersion "25.0.2"

    defaultConfig {
        minSdkVersion 19
        targetSdkVersion 19

        ndk {
            abiFilters ''armeabi'', ''armeabi-v7a'', ''x86''
        }

        externalNativeBuild {
            cmake {
                cppFlags ''-std=c++11''
                arguments ''-DANDROID_TOOLCHAIN=clang'',
                        ''-DANDROID_PLATFORM=android-19'',
                        ''-DANDROID_STL=gnustl_static'',
                        ''-DANDROID_ARM_NEON=TRUE'',
                        ''-DANDROID_CPP_FEATURES=exceptions rtti''
            }
        }
    }

    externalNativeBuild {
        cmake {
             path ''src/main/jni/CMakeLists.txt''
        }
        //ndkBuild {
        //   path ''src/main/jni/Android.mk''
        //}
    }
}

Para obtener más detalles, consulte la página de Google sobre cómo agregar código nativo .

Después de configurar esto correctamente, puede ./gradlew installDebug y listo. También deberás ser consciente de que el NDK se está moviendo a clang ya que gcc ahora está obsoleto en el NDK de Android.

Answer 2

Acabo de tener problemas muy similares con las compilaciones de gradle / agregando la biblioteca .jar. Lo tengo trabajando por una combinación de:

1. Mover la carpeta libs hasta la raíz del proyecto (el mismo directorio que ''src'') y agregar la biblioteca a esta carpeta en el buscador (usando Mac OS X)
2. En Android Studio, haga clic derecho en la carpeta para agregar como biblioteca
3. Editando las dependencias en el archivo build.gradle, agregando compile fileTree(dir: ''libs'', include: ''*.jar'')}

PERO, lo que es más importante e irritante, solo unas horas después de que funcioné, Android Studio acaba de lanzar 0.3.7, que dice haber resuelto muchos problemas de gradle, como agregar bibliotecas .jar

http://tools.android.com/recent

Espero que esto ayude a la gente!

Answer 3

Aquí está mi solución para usuarios de Mac, creo que también funciona para Windows:

Primero ve a tu barra de herramientas de Android Studio

Build> Make Project (mientras están en línea, dejen que se descarguen los archivos) y luego

Build> Compile Module "aquí se muestra el nombre de tu aplicación" (aún en línea, deja que los archivos
descargar y terminar) y luego

Ejecuta tu aplicación que ya está lista. Lanzará tu emulador, lo configurará y luego lo ejecutará.

¡¡¡Eso es!!! Happy Coding chicos !!!!!!!

Answer 4

Nota : Esta respuesta es puramente de Gradle, la uso en IntelliJ de forma regular, pero no sé cómo es la integración con Android Studio. Soy un creyente en saber lo que está pasando para mí, así que así es como uso Gradle y Android.

Ejemplo completo de TL; DR : https://github.com/ethankhall/driving-time-tracker/

Descargo de responsabilidad : Este es un proyecto en el que estoy / estaba trabajando.

Gradle tiene una estructura defined (que puede cambiar, el enlace en la parte inferior le dice cómo) que es muy similar a Maven si alguna vez lo ha utilizado.

Project Root
+-- src
|   +-- main (your project)
|   |   +-- java (where your java code goes)
|   |   +-- res  (where your res go)
|   |   +-- assets (where your assets go)
|   |   /-- AndroidManifest.xml
|   /-- instrumentTest (test project)
|       /-- java (where your java code goes)
+-- build.gradle
/-- settings.gradle

Si solo tiene un proyecto, el archivo settings.gradle no es necesario. Sin embargo, desea agregar más proyectos, entonces lo necesitamos.

Ahora echemos un vistazo a ese archivo build.gradle. Vas a necesitar esto en él (para agregar las herramientas de Android)

build.gradle

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath ''com.android.tools.build:gradle:0.3''
    }
}

Ahora tenemos que decirle a Gradle sobre algunas de las piezas de Android. Es bastante simple. Una básica (que funciona en la mayoría de mis casos) se parece a lo siguiente. Tengo un comentario en este bloque, me permitirá especificar el nombre y el código de la versión al generar el APK.

build.gradle

apply plugin: "android"
android {
        compileSdkVersion 17
        /*
        defaultConfig {
            versionCode = 1
            versionName = "0.0.0"
        }
        */
    }

Algo que vamos a querer agregar, para ayudar a cualquiera que aún no haya visto la luz de Gradle, una forma de usar el proyecto sin instalarlo.

build.gradle

task wrapper(type: org.gradle.api.tasks.wrapper.Wrapper) {
    gradleVersion = ''1.4''
}

Entonces ahora tenemos un proyecto para construir. Ahora vamos a agregar los otros. Los puse en un directorio, tal vez lo llamo deps, o subProjects. Realmente no importa, pero necesitarás saber dónde lo pones. Para decirle a Gradle dónde están los proyectos, tendrá que agregarlos a settings.gradle.

Estructura de directorios:

Project Root
+-- src (see above)
+-- subProjects (where projects are held)
|   +-- reallyCoolProject1 (your first included project)
|       /-- See project structure for a normal app
|   /-- reallyCoolProject2 (your second included project)
|       /-- See project structure for a normal app
+-- build.gradle
/-- settings.gradle

settings.gradle:

include '':subProjects:reallyCoolProject1''
include '':subProjects:reallyCoolProject2''

Lo último que debe asegurarse es que los subproyectos / reallyCoolProject1 / build.gradle tengan el apply plugin: "android-library" lugar de apply plugin: "android" .

Al igual que todos los proyectos de Gradle (y Maven) ahora debemos contarle al proyecto raíz sobre su dependencia. Esto también puede incluir cualquier dependencia Java normal que desee.

build.gradle

dependencies{
    compile ''com.fasterxml.jackson.core:jackson-core:2.1.4''
    compile ''com.fasterxml.jackson.core:jackson-databind:2.1.4''
    compile project(":subProjects:reallyCoolProject1")
    compile project('':subProjects:reallyCoolProject2'')
}

Sé que esto parece un montón de pasos, pero son bastante fáciles una vez que lo haces una o dos veces. De esta forma también le permitirá construir en un servidor de CI suponiendo que tiene instalado el SDK de Android.

Nota lateral de NDK: si va a utilizar el NDK, va a necesitar algo como a continuación. El archivo build.gradle de ejemplo se puede encontrar aquí: https://gist.github.com/khernyo/4226923

build.gradle

task copyNativeLibs(type: Copy) {
    from fileTree(dir: ''libs'', include: ''**/*.so'' )  into  ''build/native-libs''
}
tasks.withType(Compile) { compileTask -> compileTask.dependsOn copyNativeLibs }

clean.dependsOn ''cleanCopyNativeLibs''

tasks.withType(com.android.build.gradle.tasks.PackageApplication) { pkgTask ->
  pkgTask.jniDir new File(''build/native-libs'')
}

Fuentes:

1. defined
2. https://gist.github.com/khernyo/4226923
3. https://github.com/ethankhall/driving-time-tracker/