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


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

En maven, lo 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 aquí

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 conseguir Gradle crear Androide específico Eclipse archivos de proyecto?

¿Es esta una característica priorizada por Gradle?

- ACTUALIZACIÓN -

Yo sí creo que esto es un problema. Así que lo publiqué en el equipo de Herramientas de Android problema # 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 Estudio Android donde puedo importar mi proyecto gradle con dependencias a través del IDE.


32
2017-07-04 12:52


origen


Respuestas:


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 actual android herramienta 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.

Hay 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 función 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 oficial de Android: Estudio Android . Está basado en Intellij y el nuevo sistema de construcción está basado en Gradle.


9
2017-07-12 06:30



Como respondido en Número 57668 por el 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>

import-android-gradle-as-general-project

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

add-eclipse-files

.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

results

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 (mercado)

start

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


2
2018-04-15 06:29



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


2
2018-05-10 11:42



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 .classpath archivos para Eclipse de un estudio Android build.config. 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']
    }
}

correr gradle eclipse y tendrá un proyecto de 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.


2
2018-03-21 10:45



Tal vez me falta algo muy obvio, pero no es el plugin de eclipse ¿Que estas 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 IDEA plugin, aunque no he usado este y no puedo hablar con él.

Espero que ayude.


1
2017-07-13 08:06



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

Ver https://github.com/greensopinion/gradle-android-eclipse para detalles.


0
2018-04-23 00:41