Añadir dependencias a través de gradle a eclipse en el proyecto android

Tengo un problema al agregar dependencias automáticamente para eclipsar el proyecto androide a través de gradle. Sólo tengo un poco de experiencia con Gradle. Hasta ahora tengo construir dos proyectos java con gradle. Una jarra y una jarra ejecutable. Esto funciona sin problemas. He utilizado el complemento eclipse para generar el proyecto eclipse y añadir los dependenies a la ruta de construcción. He añadido nuevas dependencias al script gradle, inicié gradle con gradle eclipse, actualizo mi proyecto y las dependencias existen en el camino de construcción y puedo usarlas. Aquí está la parte importante de ese guión.

apply plugin: 'java' apply plugin: 'eclipse' repositories { mavenCentral() } dependencies { compile 'commons-io:commons-io:2.4' } 

Por lo tanto, ahora lo probé en combinación con el complemento de Android. Aquí está mi secuencia de comandos gradle agujero.

 buildscript { repositories { mavenCentral() } dependencies { classpath 'com.android.tools.build:gradle:0.4' } } apply plugin: 'android' apply plugin: 'eclipse' repositories { mavenCentral() } dependencies { compile 'org.apache.commons:commons-lang3:3.1' } android { compileSdkVersion 17 buildToolsVersion "17" defaultConfig { minSdkVersion 14 targetSdkVersion 17 } sourceSets { main { manifest.srcFile 'AndroidManifest.xml' java.srcDirs = ['src'] resources.srcDirs = ['src'] aidl.srcDirs = ['src'] renderscript.srcDirs = ['src'] res.srcDirs = ['res'] assets.srcDirs = ['assets'] } instrumentTest.setRoot('tests') } } 

Si uso gradle eclipse no pasa nada. Entonces descubrí que el plugin de java agrega las dependencias a la trayectoria de la estructura. Así que agregué

 apply plugin: 'java' 

A él y consiguió el error que el plugin de java no es compatible con el androide plugin. Entonces encontré una solución para copiar los frascos automáticamente en la carpeta lib del proyecto.

 def libDir = file('libs') task copyLibs(type: Copy) { doFirst { libDir.mkdirs() } from configurations.runtime into libDir } 

Pero esta tarea necesita el plugin java también para las configuraciones. Runtime. Necesito el complemento de Android para crear el archivo apk, por lo que no es una solución para eliminar el complemento de Android. ¿Tiene alguien una idea si es posible agregar las dependencias a la ruta de construcción o la carpeta lib en el proyecto ecipse que es compatible con el complemento de Android?

EDIT: Una de mis ideas era poner el java-plugin en el eclipse-plugin, de modo que sólo se aplicará cuando se aplique el complemento eclipse. Algo como esto:

 apply plugin: 'eclipse' eclipse{ apply plugin: 'java' } 

Pero sigo recibiendo el error de que los complementos java y android no son compatibles. Tal vez entiendo gradle mal, pero normalmente el complemento de java debe aplicarse sólo cuando inicio el complemento de eclipse y no el complemento de android. Me temo que mi comprensión y experiencia de gradle no es lo suficientemente bueno para resolver esto de esta manera o entender por qué no es posible.

5 Solutions collect form web for “Añadir dependencias a través de gradle a eclipse en el proyecto android”

Mi solución se basa fuera de Rafael en que copia dependencias al directorio de las libs que es utilizado solamente por Android. Sin embargo voy más lejos para explotar completamente los AAR referenciados para su uso en Eclipse.

Archivo de generación de Gradle

Añada lo siguiente al final de sus proyectos de Android build.gradle:

 task copyJarDependencies(type: Copy) { description = 'Used for Eclipse. Copies all dependencies to the libs directory. If there are any AAR files it will extract the classes.jar and rename it the same as the AAR file but with a .jar on the end.' libDir = new File(project.projectDir, '/libs') println libDir println 'Adding dependencies from compile configuration' configurations.compile.filter {it.name.endsWith 'jar'}.each { File file -> moveJarIntoLibs(file)} println 'Adding dependencies from releaseCompile configuration' configurations.releaseCompile.filter {it.name.endsWith 'jar'}.each { File file -> moveJarIntoLibs(file)} println 'Adding dependencies from debugCompile configuration' configurations.debugCompile.filter {it.name.endsWith 'jar'}.each { File file -> moveJarIntoLibs(file)} println 'Adding dependencies from instrumentTestCompile configuration' configurations.instrumentTestCompile.filter {it.name.endsWith 'jar'}.each { File file -> moveJarIntoLibs(file)} println 'Extracting dependencies from compile configuration' configurations.compile.filter {it.name.endsWith 'aar'}.each { File file -> moveAndRenameAar(file) } println 'Extracting dependencies from releaseCompile configuration' configurations.releaseCompile.filter {it.name.endsWith 'aar'}.each { File file -> moveAndRenameAar(file) } println 'Extracting dependencies from debugCompile configuration' configurations.debugCompile.filter {it.name.endsWith 'aar'}.each { File file -> moveAndRenameAar(file) } println 'Extracting AAR dependencies from instrumentTestCompile configuration' configurations.instrumentTestCompile.filter {it.name.endsWith 'aar'}.each { File file -> moveAndRenameAar(file) } } void moveJarIntoLibs(File file){ println 'Added jar ' + file copy{ from file into 'libs' } } void moveAndRenameAar(File file){ println 'Added aar ' + file def baseFilename = file.name.lastIndexOf('.').with {it != -1 ? file.name[0..<it] : file.name} // directory excluding the classes.jar copy{ from zipTree(file) exclude 'classes.jar' into 'libs/'+baseFilename } // Copies the classes.jar into the libs directory of the expoded AAR. // In Eclipse you can then import this exploded ar as an Android project // and then reference not only the classes but also the android resources :D copy{ from zipTree(file) include 'classes.jar' into 'libs/' + baseFilename +'/libs' rename { String fileName -> fileName.replace('classes.jar', baseFilename + '.jar') } } } 

Construcción con Gradle

Correr :

"gradle clean build"

Debe encontrar todas las dependencias y explotó AARs en su directorio libs. Esto es todo lo que Eclipse debería necesitar.

Importación en Eclipse

Ahora es donde comienza el beneficio real. Después de haber generado el directorio de libs desde el paso gradle arriba, notará que hay también carpetas allí. Esas nuevas carpetas son las dependencias AAR explotadas de su archivo build.gradle.

Ahora la parte más interesante es que cuando usted importa su proyecto Android existente en Eclipse también detectará las carpetas AAR explotadas como proyectos que puede importar también!

1. Importe esas carpetas bajo el directorio libs de su proyecto, no importe carpetas 'build', estas son generadas por Gradle

2. Asegúrese de realizar un proyecto -> Limpiar en todos los proyectos AAR que haya agregado. En su área de trabajo compruebe que cada proyecto explotado de AAR tiene lo siguiente en el proyecto.properties:

 target=android-<YOUR INSTALLED SKD VERSION GOES HERE> android.library=true 

3. Ahora en su proyecto principal de Android sólo puede agregar las referencias de la biblioteca con ADT o simplemente puede editar el archivo project.properties y agregar

android.libraries.reference.1=libs/someExplodedAAR/

4. Ahora puede hacer clic con el botón derecho del ratón en su proyecto principal de Android y Ejecutar como -> Aplicación de Android .

¿Pero qué significa esto?

  1. Bueno, significa que no necesitas el código fuente de cualquiera de tus dependencias de Android AAR Gradle para referenciarte tanto a las clases como a los recursos de Eclipse.

  2. El script de compilación gradle anterior toma el archivo AAR y lo prepara para su uso en Eclipse. Una vez que lo agregue a su espacio de trabajo, estará listo para concentrarse únicamente en su proyecto principal de Android.

  3. Ahora puede depurar y desarrollar utilizando Eclipse y desplegar utilizando ADT con dependencias AAR que están correctamente agrupadas en el APK. Cuando necesite hacer algunas compilaciones específicas, entonces puede usar gradle.

Finalmente he encontrado una solución que funciona para mí. Esta tarea copia las dependencias a la carpeta libs de proyectos.

 task copyDependencies(type: Copy) { description = 'Copy depencies to libs. Useful for Eclipse' libDir = new File(project.projectDir, '/libs') println libDir println 'Adding dependencies from compile configuration' for(file in configurations.compile) { println 'Added ' + file copy { from file into libDir } } println 'Adding dependencies from releaseCompile configuration' for(file in configurations.releaseCompile) { println 'Added ' + file copy { from file into libDir } } println 'Adding dependencies from debugCompile configuration' for(file in configurations.debugCompile) { println 'Added ' + file copy { from file into libDir } } println 'Adding dependencies from instrumentTestCompile configuration' for(file in configurations.instrumentTestCompile) { println 'Added ' + file copy { from file into libDir } } } 

La siguiente tarea gradle sólo combina las dependencias de gradle en el classpath de eclipse. build.gradle a build.gradle y invocarlo con gradle gradleDep2EclipseClasspath .

  import groovy.xml.StreamingMarkupBuilder task gradleDep2EclipseClasspath() { description "Merge gradle dependencies into the eclipse class path" def files = ["compile", "releaseCompile", "debugCompile", "instrumentTestCompile"] .collect {project.configurations[it].files} .inject([] as Set) {result, files -> result + files} .asList() .unique() .grep {! it.@path.toString().contains("android-support")} def classpath = new XmlParser().parse(file(".classpath")) def libs = classpath.grep {it.'@gradle-dependency' == "true"} libs.each {classpath.remove(it)} files.collect {file -> new Node(null, "classpathentry", [ "path": file.toString(), "kind": "lib", "exported": "true", "gradle-dependency": "true" ]) }.each {classpath.append(it)} file(".classpath").withWriter {writer -> writer << new StreamingMarkupBuilder().bind { mkp.xmlDeclaration() } def printer = new XmlNodePrinter(new PrintWriter(writer)) printer.print(classpath) } } 

Gracias a la solución de JavaJedi he creado otra , usando las anotaciones de entrada / salida de Gradle. Se basa en los mismos principios, pero es más general en uso (por ejemplo, puede definir fácilmente nuevas tareas de tipo CopyJars o ExtractAars ) y permite a Gradle decidir si la copia de archivos es necesaria o no.

Aquí está mi solución basada en todas las soluciones anteriores de @JavaJedi y @gubaer.

Paso 1

Agregue la tarea copyAars a build.gradle. Descomprime y copia las dependencias de AAR en una carpeta especial "deps", en lugar de en "libs" para evitar conflictos con Android Studio y / o con otros plugins y tareas de Gradle. Después de esto, todos los AAR explotados deben importarse manualmente como proyectos de la Biblioteca Android y agregarse como dependencias al proyecto principal de Eclipse. Esta es una solución modificada de @JavaJedi.

 task copyAars << { configurations.compile.filter { it.name.endsWith 'aar' }.each { File file -> copyAndRenameAar(file) } } void copyAndRenameAar(File file) { println 'Added aar ' + file def baseFilename = file.name.lastIndexOf('.').with { it != -1 ? file.name[0..<it] : file.name } // directory excluding the classes.jar copy { from zipTree(file) exclude 'classes.jar' into "deps/aars/exploded/" + baseFilename } // Copies the classes.jar into the libs directory of the expoded AAR. // In Eclipse you can then import this exploded aar as an Android project // and then reference not only the classes but also the android resources copy { from zipTree(file) include 'classes.jar' into "deps/aars/exploded/" + baseFilename + "/libs" rename { String fileName -> fileName.replace('classes.jar', baseFilename + '.jar') } } } 

Paso 2

Agregue la tarea eclipseClasspath a build.gradle. JAR dependencias se agregan de una manera diferente. Se filtran y se añaden directamente al archivo .classpath, por lo que están disponibles automáticamente en el proyecto principal de Eclipse. Esta es una solución modificada de @gubaer. Incluye sólo JARs, excluyendo AARs y solo desde la configuración de "compilación", pero puedes agregar fácilmente más configs.

 task eclipseClasspath << { def classpath = new XmlParser().parse(file(".classpath")) def libs = classpath.grep { it.'@gradle-dependency' == "true" } libs.each { classpath.remove(it) } configurations.compile.filter { it.name.endsWith 'jar' } .collect { file -> new Node(null, "classpathentry", [ "path": file.toString(), "kind": "lib", "exported": "true", "gradle-dependency": "true" ]) } .each { classpath.append(it) } file(".classpath").withWriter { writer -> writer << new groovy.xml.StreamingMarkupBuilder().bind { mkp.xmlDeclaration() } def printer = new XmlNodePrinter(new PrintWriter(writer)) printer.print(classpath) } } 

Paso 3

Instale el complemento http://marketplace.eclipse.org/content/java-source-attacher en Eclipse. Después de eso podrás hacer clic derecho en cada JAR y elegir "Adjuntar fuente Java". Para las dependencias de Gradle esto funciona el 99% del tiempo en mi experiencia.

  • Construir sólo por defecto (sin sabores / variantes)
  • Error: Tiempo de espera esperando para bloquear caché de clase buildscript para el archivo de construcción cuando cambia minSdkVersion
  • Cómo solucionar la entrada duplicada de entrada duplicada: javax / annotation / ParametersAreNullableByDefault.class
  • El método debe anularse en si se llama "en Android Studio
  • Gradle: El nombre de archivo, el nombre de directorio o la sintaxis de etiquetas de volumen es incorrecto
  • Sonar, Gradle y Android devuelven 0 número
  • DEX falla al analizar un frasco incluyendo BuildConfig y R usando Gradle, pero trabajó con Ant
  • Uso del proyecto Scala con Gradle para Android
  • Uso de SimpleXML con Android y Gradle
  • Gradle se queda atascado en 'build' o 'assembleDebug' al usar la versión de 64 bits o 32 bits de Android Studio
  • La generación de Gradle falla con "No se puede leer la ruta" cuando se ejecuta instantánea está deshabilitada
  • FlipAndroid es un fan de Google para Android, Todo sobre Android Phones, Android Wear, Android Dev y Aplicaciones para Android Aplicaciones.