Ajouter des dépendances via gradle à éclipse dans le projet android

j'ai un problème en ajoutant automatiquement les dépendances à l'éclipse du projet android via gradle.
J'ai seulement un peu d'expérience avec gradle. Jusqu'à maintenant, j'ai de la construction de deux projets java avec gradle. Un bocal et un exécutable jar. Cela fonctionne sans problèmes.
J'ai utilisé le plugin eclipse pour générer le projet eclipse et ajouter le dependenies pour le build path. J'ai ajouté de nouvelles dépendances à l'gradle script, a commencé à gradle avec gradle eclipse ,mise à jour de mon projet et les dépendances qui existent dans le build path et je peux utilisé. Ici est la partie importante de ce script.

apply plugin: 'java'
apply plugin: 'eclipse'
repositories {
   mavenCentral()
}

dependencies {
   compile 'commons-io:commons-io:2.4'
}

Alors, maintenant, je l'ai essayé en combinaison avec l'android plugin. Voici mon trou gradle script.

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 j'utilise gradle eclipse rien ne se passe. Puis j'ai découvert que le java plugin ajoute les dépendances du chemin de génération. J'ai donc ajouté

apply plugin: 'java'

et obtenu l'erreur que le plugin java n'est pas compatible avec l'android plugin.
Ensuite, j'ai trouvé une solution pour copier les pots automatiquement dans le dossier lib du projet.

def libDir = file('libs')

task copyLibs(type: Copy) {

    doFirst {
        libDir.mkdirs()
    }
    from configurations.runtime
    into libDir
}

Mais cette tâche a besoin du plug-in java pour les configurations.moment de l'exécution.
J'ai besoin de l'android plugin pour créer le fichier apk, de sorte qu'il n'est pas une solution pour enlever le android plugin.
A une idée à quelqu'un si il est possible d'ajouter les dépendances du chemin de génération ou dossier lib dans ecipse projet qui est compatible avec l'android plugin?

EDIT:
Une de mes idées était de mettre le java plugin pour eclipse-plugin, de sorte qu'il ne sera appliquée que lorsque le plugin eclipse sera appliqué. Quelque chose comme ceci:

apply plugin: 'eclipse'

eclipse{
    apply plugin: 'java'
}

Mais j'ai toujours l'erreur que le java et android plugins ne sont pas compatibles.
Peut-être que je comprends gradle mal, mais normalement le plugin java doit être appliqué que lorsque je démarre le plugin eclipse et pas android plugin. Im peur que ma compréhension et mon expérience de gradle est pas assez bon pour résoudre ce de cette façon ou de comprendre pourquoi il n'est pas possible.

source d'informationauteur Rafael

Ma solution est basée sur la Rafael en ce qu'il copie les dépendances dans le répertoire libs qui n'est utilisé que par Android. J'ai cependant aller plus loin pour complètement exploser le référencés AAR pour une utilisation dans Eclipse.

Fichier De Build Gradle

Ajouter le texte suivant à la fin de votre Android des projets de construction.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')
}
}
}

Bâtiment avec Gradle

Exécuter :

"gradle clean build"

Vous devriez trouver toutes les dépendances et fait exploser le ces dans votre répertoire libs. C'est tout l'Éclipse.

Importer dans Eclipse

Maintenant c'est où l'avantage réel commence. Après que vous avez généré le répertoire libs de la gradle l'étape ci-dessus, vous remarquerez qu'il y a des dossiers. Les nouveaux dossiers sont la éclatée de l'AAR dépendances de votre construction.gradle fichier.

Maintenant la partie la plus cool, c'est que lorsque vous importez votre projet Android dans Eclipse il détecte également le découpage de l'AAR dossiers que les projets qu'il peut importer trop!

1. Importer les sous-dossiers de votre projet libs répertoire, de ne pas importer toute la "construction" des dossiers, ils sont générés par Gradle

2. Vous assurer que vous effectuez une Projet -> Nettoyer sur tous les AAR projets que vous avez ajoutés. Dans votre espace de travail de vérifier que chaque AAR a explosé projet a la suite du projet.propriétés :

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

3. Maintenant dans votre projet Android, vous pouvez simplement ajouter les références de bibliothèque avec soit ADT ou vous pouvez simplement modifier le projet.les propriétés de fichier et ajouter

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

4. Maintenant, vous pouvez droit-cliquez sur le principal de votre projet Android et Exécuter en tant qu' -> Application Android.

Mais qu'est-ce à dire?

Bien, cela signifie que vous n'avez pas besoin du code source pour votre Android AAR Gradle dépendances afin de faire référence à la fois c'est des classes et des ressources dans Eclipse.
Le script de build gradle ci-dessus prend l'AAR fichier et la prépare pour une utilisation dans Eclipse. Une fois que vous l'ajouter à votre espace de travail que vous êtes prêt à vous concentrer sur votre principal projet Android.
Vous pouvez maintenant déboguer et de développer l'utilisation d'Eclipse et de déployer à l'aide de l'outil ADT avec de l'AAR dépendances être correctement intégrés dans le APK. Lorsque vous avez besoin de faire certaines des constructions particulières, alors vous pouvez utiliser gradle.

Enfin, j'ai trouvé une solution qui fonctionne pour moi. Cette tâche copie les dépendances pour les projets de dossier libs.

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

Suivantes gradle tâche il fusionne gradle dépendances dans l'éclipse du classpath. Ajouter à build.gradle et à l'appeler avec 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)
}
}

0

Grâce à JavaJedi de l' solution que j'ai créé un autreà l'aide de Gradle d'entrée/sortie du annotations. Il est basé sur les mêmes principes, mais il est plus général en cours d'utilisation (par exemple, vous pouvez facilement définir de nouvelles tâches de type CopyJars ou ExtractAars) et permet de Gradle pour décider si la copie de fichier est nécessaire ou non.

Voici ma solution basée sur toutes les solutions précédentes de @JavaJedi et @gubaer.

Étape 1

Ajouter copyAars tâche de construire.gradle. Il le déballe et des copies de l'AAR dépendances dans un dossier spécial "deps", plutôt que pour "libs" pour éviter tout conflit avec Android Studio et/ou dans d'autres Gradle des plugins et des tâches. Après que tout a explosé AARs devrait être importés manuellement comme Android de projets de Bibliothèque et a ajouté que les dépendances à l'objectif principal du projet dans Eclipse. C'est une modification de la solution 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') }
}
}

Étape 2

Ajouter eclipseClasspath tâche de construire.gradle. JAR dépendances sont ajoutés de manière différente. Ils sont filtrés et d'ajouter directement .classpath de fichier, de sorte qu'ils sont automatiquement disponibles dans Eclipse projet principal. C'est une modification de la solution de @gubaer. Il ne comprend que des Pots, à l'exclusion des AARs et seulement à partir de "compiler" de la configuration, mais vous pouvez facilement ajouter d'autres 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)
}
}

Étape 3

Installer http://marketplace.eclipse.org/content/java-source-attacher plugin dans Eclipse. Après cela, vous serez en mesure de faire un clic droit sur chaque POT et choisissez l'option "Joindre Source Java". Pour Gradle dépendances cela fonctionne 99% du temps dans mon expérience.

Vous devez vous connecter pour publier un commentaire.