studio - Cómo usar Gradle para generar archivos de proyectos Eclipse e Intellij para proyectos de Android

importar proyecto android studio

Question

¿Es posible generar archivos de proyectos Eclipse e Intellij para proyectos de Android usando Gradle?

En maven haríamos mvn eclipse:eclipse y en PlayFramework haríamos play eclipsify . ¿Tiene Gradle esta característica para proyectos de Android?

He instalado Gradle (1.6) y Android SDK Manager (22.0.1) explicados here

Este es mi archivo build.gradle:

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

apply plugin: ''android''
apply plugin: ''eclipse''

sourceCompatibility = 1.7
version = ''1.0.2''

repositories {
    mavenCentral()
}

dependencies {
  compile fileTree(dir: ''libs'', include: ''*.jar'')
}

android {
    buildToolsVersion "17" 
    compileSdkVersion 8
    defaultConfig {
        versionCode 1
        versionName "1.0"
        minSdkVersion 7
        targetSdkVersion 8
    }
    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'')
    }
}

Y luego ejecuto el comando:

gradle clean build cleanEclipse eclipse

Se construye muy bien, pero cuando importo el proyecto en Eclipse parece un proyecto Java normal.

¿Alguien sabe cómo hacer que Gradle cree archivos de proyecto Eclipse específicos de Android ?

¿Es esta una característica priorizada por Gradle?

- ACTUALIZACIÓN -

Yo sí creo que esto es un problema. Así que lo publiqué en la edición del equipo de Herramientas de Android # 57668 . Por favor, pruébalo para que prioricen el problema :)

- ACTUALIZACIÓN -

No parece que el equipo de Herramientas de Android esté investigando este problema. Así que por ahora me he convertido a Android Studio, donde puedo importar mi proyecto gradle con dependencias a través del IDE.

Answer 1

Como respondió el problema 57668 del equipo de Android (planteado por @arcone)

Miembro del proyecto n. ° 2 x ... @ android.com

El complemento de eclipse no es compatible con el complemento de Android.

No podrá importar un proyecto gradle de Android en Eclipse utilizando la compatibilidad predeterminada de Gradle en Eclipse.

Para que funcione en Eclipse tendremos que cambiar el plugin de Gradle para Eclipse, de la misma manera que estamos modificando el soporte de Gradle en IntelliJ

Ese es el equipo de Android que está trabajando en el plugin de Gradle para IntelliJ y el plugin de gradle para Eclipse necesita ser actualizado también.

Lo que es posible con Eclipse ahora es

.1. importar el proyecto como proyecto general

.project

<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
    <name>OpenSpritz-Android</name>
    <comment></comment>
    <projects>
    </projects>
    <buildSpec>
    </buildSpec>
    <natures>
    </natures>
</projectDescription>

.2. Pon 2 Eclipse. "dot" archivos en módulos en /OpenSpritz-Android/app/src/main y /OpenSpritz-Android/lib/src/main

.project

<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
    <name>OpenSpritz-Android-app</name>
    <comment></comment>
    <projects>
    </projects>
    <buildSpec>
        <buildCommand>
            <name>com.android.ide.eclipse.adt.ResourceManagerBuilder</name>
            <arguments>
            </arguments>
        </buildCommand>
        <buildCommand>
            <name>com.android.ide.eclipse.adt.PreCompilerBuilder</name>
            <arguments>
            </arguments>
        </buildCommand>
        <buildCommand>
            <name>org.eclipse.jdt.core.javabuilder</name>
            <arguments>
            </arguments>
        </buildCommand>
        <buildCommand>
            <name>com.android.ide.eclipse.adt.ApkBuilder</name>
            <arguments>
            </arguments>
        </buildCommand>
    </buildSpec>
    <natures>
        <nature>com.android.ide.eclipse.adt.AndroidNature</nature>
        <nature>org.eclipse.jdt.core.javanature</nature>
    </natures>
</projectDescription>

.classpath

<?xml version="1.0" encoding="UTF-8"?>
<classpath>
    <classpathentry kind="src" path="java"/>
    <classpathentry kind="src" path="gen"/>
    <classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
    <classpathentry exported="true" kind="con" path="com.android.ide.eclipse.adt.LIBRARIES"/>
    <classpathentry exported="true" kind="con" path="com.android.ide.eclipse.adt.DEPENDENCIES"/>
    <classpathentry kind="output" path="bin/classes"/>
</classpath>

.3. Importar como código de Android existente en el espacio de trabajo

luego puede navegar por el código de una manera familiar, pero incluso después de eso no podrá ejecutar con Eclipse ADT.

.4.

Ahora puede ejecutar compilación y tareas con gradle CLI o Nodeclipse / Enide Gradle para Eclipse ( marketplace )

discutir en https://github.com/Nodeclipse/nodeclipse-1/issues/148

Answer 2

Creé un nuevo complemento de Gradle que genera los archivos apropiados Eclipse .project y .classpath , en función de la respuesta proporcionada por Johannes Brodwall en este desbordamiento de pila.

Ver github.com/greensopinion/gradle-android-eclipse para más detalles.

Answer 3

Gradle en sí es una herramienta de compilación genérica, no está creada específicamente para Android.

Toda la funcionalidad está habilitada usando complementos. Tradicionalmente, los complementos de compilación no generan estructura de proyecto. Ese es el trabajo de las herramientas específicas del proyecto. El plug-in de Android para Gradle sigue esto.

El problema es que la herramienta actual de android en SDK genera un tipo antiguo de estructura de proyecto (compilaciones ant). La nueva estructura del proyecto solo se puede generar a través de Android Studio.

Existe un concepto de archetypes en herramientas como Maven, que permiten el uso de plantillas de proyectos. Gradle aún no es compatible (se han realizado solicitudes para esta función).

Consulte este hilo: http://issues.gradle.org/browse/GRADLE-1289 , algunos usuarios han proporcionado scripts para generar estructura.

La característica de inicialización de compilación está en progreso: https://github.com/gradle/gradle/blob/master/design-docs/build-initialisation.md

Esperemos que alguien pueda escribir un guión para hacerlo, consulte esta guía para conocer la nueva estructura del proyecto: http://tools.android.com/tech-docs/new-build-system/user-guide

Actualizar

Ahora hay un IDE Android oficial: Android Studio . Está basado en Intellij y el nuevo sistema de construcción está basado en Gradle.

Answer 4

Hay cuatro problemas con la combinación de los complementos de Gradle ''com.android.application'' y ''eclipse'': en primer lugar, los classpaths de configuración no se agregan al classpath de Eclipse, pero esto es fácil de corregir. En segundo lugar, se debe hacer algo acerca de las dependencias .AAR. Esto fue un poco más complicado. En tercer lugar, debemos incluir las fuentes generadas para cosas como R.java. Finalmente, debemos incluir Android.jar en sí mismo.

Pude hackear juntos una configuración gradle que generaría archivos .classpath adecuados para Eclipse desde un build.config Android Studio. Los efectos fueron muy satisfactorios para mi fan de la CPU, que se había estado ejecutando constantemente con Android Studio. Eclipse ve el proyecto resultante como un proyecto de Java totalmente funcional, pero solo eso.

Terminé poniendo lo siguiente directamente en build.gradle en mi proyecto de aplicación:

apply plugin: ''eclipse''
eclipse {
    pathVariables ''GRADLE_HOME'': gradle.gradleUserHomeDir, "ANDROID_HOME": android.sdkDirectory 
    classpath {
        plusConfigurations += [ configurations.compile, configurations.testCompile ]

        file {
            beforeMerged { classpath ->
                classpath.entries.add(new org.gradle.plugins.ide.eclipse.model.SourceFolder("src/main/java", "bin"))
                // Hardcoded to use debug configuration
                classpath.entries.add(new org.gradle.plugins.ide.eclipse.model.SourceFolder("build/generated/source/r/debug", "bin"))
                classpath.entries.add(new org.gradle.plugins.ide.eclipse.model.SourceFolder("build/generated/source/buildConfig/debug", "bin"))
            }

            whenMerged { classpath ->
                def aars = []
                classpath.entries.each { dep ->
                    if (dep.path.toString().endsWith(".aar")) {
                        def explodedDir = new File(projectDir, "build/intermediates/exploded-aar/" + dep.moduleVersion.group + "/" + dep.moduleVersion.name + "/" + dep.moduleVersion.version + "/jars/")
                        if (explodedDir.exists()) {
                            explodedDir.eachFileRecurse(groovy.io.FileType.FILES) {
                                if (it.getName().endsWith("jar")) {
                                    def aarJar = new org.gradle.plugins.ide.eclipse.model.Library(fileReferenceFactory.fromFile(it))
                                    aarJar.sourcePath = dep.sourcePath
                                    aars.add(aarJar)
                                }
                            }
                        } else {
                            println "Warning: Missing " + explodedDir
                        }
                    }
                }
                classpath.entries.removeAll { it.path.endsWith(".aar") }
                classpath.entries.addAll(aars)

                def androidJar = new org.gradle.plugins.ide.eclipse.model.Variable(
                    fileReferenceFactory.fromPath("ANDROID_HOME/platforms/" + android.compileSdkVersion + "/android.jar"))
                androidJar.sourcePath = fileReferenceFactory.fromPath("ANDROID_HOME/sources/" + android.compileSdkVersion) 
                classpath.entries.add(androidJar)
            }
        }
    }
}

// We need build/generated/source/{r,buildConfig}/debug to be present before generating classpath
//  This also ensures that AARs are exploded 
eclipseClasspath.dependsOn "generateDebugSources"


// Bonus: start the app directly on the device with "gradle startDebug"
task startDebug(dependsOn: "installDebug") << {
    exec {
        executable = new File(android.sdkDirectory, ''platform-tools/adb'')
        args = [''shell'', ''am'', ''start'', ''-n'', android.defaultConfig.applicationId + ''/.MainActivity'']
    }
}

Ejecute gradle eclipse y tendrá un proyecto Eclipse que se puede importar y compilar. Sin embargo, este proyecto actúa como un proyecto Java normal. Para construir el apk, tengo que regresar a la línea de comandos gradle y ejecutar gradle installDebug . gradle processDebugResources recoge los cambios en los archivos XML de Android y regenera los archivos en build/generated/source . Utilizo el programa "monitor" con Android SDK para ver los registros de la aplicación. Hasta ahora no he encontrado ninguna forma de depurar sin Android Studio.

Las únicas características que extraño de Android Studio son la depuración (¡pero quién tiene tiempo para errores!) Y la edición de recursos visualmente.

Answer 5

Lo siguiente funcionó para mí

eclipse.classpath.plusConfigurations += configurations.compile

eclipse.classpath.file {
    beforeMerged { classpath ->
    classpath.entries.removeAll() { c -> 
        c.kind == ''src''
    }
}

withXml {
    def node = it.asNode()

    node.appendNode(''classpathentry kind="src" path="src/main/java"'')
    node.appendNode(''classpathentry kind="src" path="src/debug/java"'')
    node.appendNode(''classpathentry kind="src" path="gen"'')

    node.children().removeAll() { c ->
        def path = c.attribute(''path'')
        path != null && (
                path.contains(''/com.android.support/support-v4'')
                )
    }
  }
}

eclipse.project {
   name = ''AndroidGradleBasic''

   natures ''com.android.ide.eclipse.adt.AndroidNature''
   buildCommand ''com.android.ide.eclipse.adt.ResourceManagerBuilder''
   buildCommand ''com.android.ide.eclipse.adt.PreCompilerBuilder''
   buildCommand ''com.android.ide.eclipse.adt.ApkBuilder''
}

Fuente - http://blog.gouline.net/2013/11/02/new-build-system-for-android-with-eclipse/

Muestra - https://github.com/krishnaraj/oneclipboard

Answer 6

Tal vez me falta algo muy obvio, pero ¿no es el plugin de eclipse lo que estás buscando? Esto genera un archivo .project, así como un archivo .classpath y los actualiza según sea necesario cuando se ejecutan veces posteriores.

También hay un complemento IDEA , aunque no he usado este y no puedo hablar con él.

Espero que ayude.