web-dev-qa-db-fra.com

Comment utiliser Gradle pour générer des fichiers de projet Eclipse et Intellij pour les projets Android

Est-il possible de générer des fichiers de projet Eclipse et Intellij pour les projets Android en utilisant Gradle?

Dans Maven, nous ferions mvn Eclipse:eclipse et dans PlayFramework nous ferions play eclipsify. Gradle a-t-il cette fonctionnalité pour les projets Android?

J'ai installé Gradle (1.6) et Android SDK Manager (22.0.1) expliqué ici

Voici mon fichier 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')
    }
}

Et puis je lance la commande:

gradle clean build cleanEclipse Eclipse

Il se construit très bien, mais lorsque j'importe le projet dans Eclipse, il ressemble à un projet normal Java.

Tout le monde sait comment obtenir Gradle pour créer Android spécifique Fichiers de projet Eclipse ?

Est-ce une fonctionnalité prioritaire de Gradle?

- MISE À JOUR -

Je crois que c'est un problème. Je l'ai donc posté à l'équipe Android Tools problème # 57668 . Veuillez le lire pour qu'ils priorisent le problème :)

- MISE À JOUR -

Il ne ressemble pas à Android étudie ce problème. Donc pour l'instant, je suis converti en Android Studio où je peux importer mon projet Gradle avec des dépendances via l'IDE.

androideclipseideintellij-ideagradle
35
Jan-Terje Sørensen

Gradle lui-même est un outil de construction générique, il n'est pas créé spécifiquement pour Android.

Toutes les fonctionnalités sont activées à l'aide de plug-ins. Traditionnellement, les plug-ins de génération ne génèrent pas de structure de projet. C'est le travail des outils spécifiques au projet. Le plug-in Android pour Gradle suit ceci.

Le problème est que l'outil Android actuel dans le SDK génère un ancien type de structure de projet (ant builds). La nouvelle structure du projet ne peut être générée que via Android Studio.

Il existe un concept de archetypes dans des outils comme Maven, qui permettent d'utiliser des modèles de projet. Gradle ne le supporte pas encore (des demandes ont été faites pour cette fonctionnalité).

Reportez-vous à ce fil: http://issues.gradle.org/browse/GRADLE-1289 , certains utilisateurs ont fourni des scripts pour générer la structure.

La fonction d'initialisation de la construction est en cours: https://github.com/gradle/gradle/blob/master/design-docs/build-initialisation.md

Espérons que quelqu'un puisse écrire un script pour ce faire, reportez-vous à ce guide pour la nouvelle structure du projet: http://tools.Android.com/tech-docs/new-build-system/user-guide

Mise à jour

Il existe maintenant un Android IDE: Android Studio officiel. Il est basé sur Intellij et le nouveau système de construction est basé sur Gradle.

9
S.D.

Il y a quatre problèmes avec la combinaison des plugins Gradle 'com.Android.application' et 'Eclipse': Premièrement, les chemins de classe de configuration ne sont pas ajoutés au chemin de classe d'Eclipse, mais c'est facile à résoudre. Deuxièmement, quelque chose doit être fait au sujet des dépendances .AAR. C'était un peu plus compliqué. Troisièmement, nous devons inclure les sources générées pour des choses comme R.Java. Enfin, nous devons inclure Android.jar lui-même.

J'ai pu pirater ensemble une configuration gradle qui générerait une bonne .classpath fichiers pour Eclipse à partir d'un Android Studio build.config. Les effets étaient très satisfaisants pour mon fan de CPU, qui fonctionnait constamment avec Android Studio. Eclipse voit le projet résultant comme un projet Java Java, mais entièrement fonctionnel) seulement ça.

J'ai fini par mettre les éléments suivants directement dans build.gradle dans mon projet d'application:

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']
    }
}

Courir gradle Eclipse et vous aurez un projet Eclipse qui peut être importé et compilé. Cependant, ce projet agit comme un projet Java normal. Afin de construire l'apk, je dois revenir à la ligne de commande gradle et exécuter gradle installDebug. gradle processDebugResources récupère les modifications dans les fichiers Android XML et régénère les fichiers sous build/generated/source. J'utilise le programme "moniteur" avec Android SDK pour afficher les journaux de l'application. Je n'ai jusqu'à présent trouvé aucun moyen de déboguer sans Android Studio.

Les seules fonctionnalités qui me manquent de Android Studio sont le débogage (mais qui a le temps pour les bugs!) Et l'édition visuelle des ressources.

3
Johannes Brodwall

Comme répondu dans problème 57668 par Android (soulevée par @arcone)

Membre du projet # 2 x ... @ Android.com

Le plugin Eclipse n'est pas compatible avec le plugin Android.

Vous ne pourrez pas importer un projet de gradle Android Android dans Eclipse en utilisant la prise en charge Gradle par défaut dans Eclipse.

Pour le faire fonctionner dans Eclipse, nous devrons changer le plugin Gradle pour Eclipse, de la même manière que nous modifions le support Gradle dans IntelliJ

C'est-à-dire Android travaille sur le plugin gradle pour IntelliJ et le plugin gradle pour Eclipse doit également être mis à jour.

Ce qui est possible avec Eclipse maintenant, c'est

.1. importer le projet en tant que projet général

.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. Mettez 2 Eclipse. "dot" fichiers en modules dans /OpenSpritz-Android/app/src/main et /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. Importer comme existant Android Code dans Workspace

results

vous pouvez ensuite parcourir le code de manière familière, mais même après cela, vous ne pourrez pas exécuter avec Eclipse ADT.

.4.

Vous pouvez maintenant exécuter la génération et les tâches avec gradle CLI ou Nodeclipse/Enide Gradle pour Eclipse ( marketplace )

start

discuter à https://github.com/Nodeclipse/nodeclipse-1/issues/148

2
Paul Verest

J'ai créé un nouveau plugin Gradle qui génère le Eclipse approprié .project et .classpath fichiers, basé sur la réponse fournie par Johannes Brodwall sur ce débordement de pile.

Voir https://github.com/greensopinion/gradle-Android-Eclipse pour plus de détails.

2
David Green

Ce qui suit a fonctionné pour moi

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'
}

Source - http://blog.gouline.net/2013/11/02/new-build-system-for-Android-with-Eclipse/

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

2
Krishnaraj

Peut-être que je manque quelque chose de très évident, mais le plugin Eclipse n'est-il pas ce que vous recherchez? Cela génère un fichier .project ainsi qu'un fichier .classpath et les met à jour si nécessaire lors de l'exécution ultérieure.

Il y a aussi un plugin IDEA , bien que je n'aie pas utilisé celui-ci et que je ne puisse pas en parler.

J'espère que ça t'as aidé.

1
Myles