modulos - libreria android studio
¿Cómo construir una biblioteca de Android con Android Studio y Gradle? (4)
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.
- Crea un nuevo proyecto llamado
MyApp - Haga clic en
File > New Module, elijaAndroid LibraryyMyLibnombreMyLib - 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
- Haga clic en
File > Project Structure > Modules > MyApp-MyApp - Cambiar a la pestaña de
Dependencies - Haga clic en
+ > Module Dependencyy seleccioneMyLib - Haga clic en
ApplyyOK - 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.
- Agregue el
compile project('':SubProjects:MyLib'')aMyLib/build.gradle - Eliminar
compile files(''libs/android-support-v4.jar'')desdeMyLib/build.gradle - 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 .
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.
Acabo de tener problemas muy similares con las compilaciones de gradle / agregando la biblioteca .jar. Lo tengo trabajando por una combinación de:
- 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)
- En Android Studio, haga clic derecho en la carpeta para agregar como biblioteca
- 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!
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 !!!!!!!
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: