Par rapport les dépendances d'un projet dans Gradle?

Lors de la spécification de Gradle les dépendances d'un projet, puis-je éviter l'utilisation d'un plein absolue projet de nom et d'utiliser un rapport de la place? (c'est à dire dans mon exemple je ne veux pas de spécifier de manière explicite :app-un lors de la référence :domaine: a)

//Directory structure
app-a/
  domain-a/
    build.gradle
  webapp-a/
    build.gradle

WebApp-Une génération.gradle:

apply plugin: 'java'

//Build.gradle for webapp-a
dependencies {

  //Works
  compile project(':app-a:domain-a')

  //Doesn't work
  compile project(projectDir.path + '/../domain-a/')

  //Doesn't work
  compile findProject('../domain-a')

  //Doesn't work
  compile project(':domain-a')
}

compiler le projet(':' + parent.nom + ':domaine-a') fonctionne, mais semble hacky
Voici un exemple qui fonctionne avec gradle2.2.1 mais pas avec android studio 1.0.2 : stackoverflow.com/questions/18936433/...

InformationsquelleAutor vicsz | 2012-03-16

gradle

0

Noms relatifs sont une mauvaise idée car ils font de votre projet dépend du projet plus vaste: il est situé dans. Qui ne devrait pas être le cas. Je suggère d'éviter d'utiliser le nom relatif.

En termes de récupérer le projet parent comme une dépendance à cette fin, la valeur par défaut est le répertoire parent ou qu'à défaut elle serait d'utiliser l'habitude de dépendance mécanisme de résolution, qui utilise les coordonnées (groupId, artifactId et version) et regarde l'objet dans le référentiel local..
- Yep .. je tendre pour les chemins relatifs/noms ... mais cela semble être une mauvaise idée dans ce cas (et à en juger par d'autres gradle construire des scripts que j'ai trouvé).
- Si elles sont ou non une bonne idée, je ne comprends pas pourquoi les chemins d'accès relatifs serait plus projet dépendant des chemins absolus? Que suggérez-vous à la place?
- Il est préférable d'avoir les projets d'être indépendant et d'échange, les dépendances de construction/sorties comme toute autre dépendance par l'intermédiaire d'un gestionnaire de référentiel ou au minimum de votre dépôt local.
- Bon point, alors je comprends ce que tu veux dire. Merci pour la clarification!
- Toujours, même sans les chemins relatifs, cette réponse ne répond pas à la problématique de la référence à un projet parent comme une dépendance.
- Cela ne répond pas à la question sur la façon dont les chemins relatifs ne peuvent être utilisés. Je suis l'élaboration d'une bibliothèque où je fournir des exemples de projets. La bibliothèque est développé dans une lib\kotlin sous-dossier si les échantillons sont des échantillons\kotlin. Mon espace de travail de la racine n'est pas liée à gradle. Je veux simplement tirer lib\kotlin dans les échantillons\kotlin et de ne pas gâcher toute ma bibliothèque arbre avec gradle.
InformationsquelleAutor Manfred Moser
39

Pour Android développement sous Android Studio et gradle, voici comment compiler une bibliothèque qui n'est pas sous votre racine du projet, mais a un chemin relatif:
1. Inclure la librairie dans les paramètres.gradle et remplacer le projectDir:
```
include 'MyTestLibProject:MyTestLib'
project(':MyTestLibProject:MyTestLib').projectDir = new File(settingsDir, '../MyTestLibProject/MyTestLib')
```
2. Modifier le build.gradle pour la bibliothèque de l'utilisation de l'android-bibliothèque plugin au lieu d'android, ce qui provoque la bibliothèque de sorties pour être inclus dans des projets de référence:
```
apply plugin: 'android-library'
```
3. Préciser que votre projet a une dépendance sur la lib par l'édition de la construction.gradle pour les non-lib projet:
```
compile project(path: ':MyTestLibProject:MyTestLib')
```
4. Si la lib comprend tous les pots que votre projet comprend également la construction de les voir comme une collision lorsque c'est la génération de l'apk. Résumé des pots dans une autre lib qui à la fois le projet et la lib de référence, ou juste exclure la collision jar du projet principal et de le laisser ramasser le pot de la dépendance:
```
dependencies {
    compile fileTree(dir: 'libs', include: '*.jar', exclude: '**/android-support-v4.jar')
    compile project(path: ':MyTestLibProject:MyTestLib')
}
```
AVERTISSEMENT: Ce n'est pas la façon dont gradle veut que vous fassiez ce - que vous avez prévu de publier les lib à l'aide de maven et puis de référence de la dépendance à l'aide de la "POM" de la publié lib (qui inclut le numéro de version). Ceci fournit une meilleure gestion de la dépendance - par exemple, maven simplifie le scénario d'avoir de nombreux projets (avec différents cycles de publication) tout en utilisant des versions différentes d'une commune de la lib. Le chemin d'accès relatif technique décrite ici est une façon rapide de se lever et courir pour les petits projets ou comme une étape intermédiaire pour les projets en cours porté de l'ant.

Référence: http://tools.android.com/tech-docs/new-build-system/user-guide#TOC-Creating-a-Library-Project
- Merci pour cette, cela fonctionne! Jusqu'à ce que toutes les bibliothèques ont leur repo maven cracher .aar fichiers, c'est la meilleure solution
- Malheureusement, cela ne fonctionne pas pour moi. L'obtention de ces génériques "Configuration avec le nom "default" est introuvable." les erreurs. Soupir.
- c qu'est-Ce que 'settingsDir' ?. Comment puis-je spécifier le chemin d'accès absolu du projet de bibliothèque?
- Dabhi Si je me souviens bien, settingsDir serait le répertoire où les paramètres.gradle est situé.
- Ce n'est pas de travailler à partir de gradle 2.3.0. Le module de la bibliothèque est ajouté dans l'android studio. Mais même après la compilation du module de la bibliothèque dans l'app construire.gradle, les fichiers de classe ne sont pas d'être généré pour la bibliothèque.
- Comment est-il répondre à la question? Le chemin d'accès dans l'exemple a encore de projet parent spécifié explicitement. Ai-je raté quelque chose
InformationsquelleAutor J c
8

Bien que l'utilisation de chemins relatifs pourrait être une mauvaise pratique, parfois, vous pourriez juste besoin de cette manière.
Néanmoins, ici, c'est comment vous pouvez l'obtenir pour fonctionner.

Vous avez besoin pour créer settings.gradle fichier à l'intérieur d'une webapp-un

webapp-un/paramètres.gradle
```
include '..:domain-a'
```
Puis dans webapp-un/build.gradle
```
compile project(':..:domain-a')
```
(ne l'ai pas testé moi-même, mais il devrait fonctionner)

EDIT:
remplacé ../domain-a par ..:domain-a dans les deux fichiers
- Cet arrêté de travailler avec Gradle 1.11, je ne sais pas pourquoi. J'ai eu à suivre les autres répondre.
InformationsquelleAutor lihsus
0

Une réponse tardive ne fait jamais de mal. Ma solution a été proche de ce que @lihsus suggéré.

Dire que vous avez la structure de projet suivante:
```
//Directory structure
app-a/
  domain-a/
    build.gradle
  webapp-a/
    build.gradle
```
Assurez-vous que votre app-un a un construire.gradle et un paramètres.gradle.

Dans le paramètres.gradle de app-un vous pouvez ensuite inclure à la fois des modules/projets tels que:
```
include ':domain-a'
include ':webapp-a'
```
Puis dans webapp-un vous pouvez ajouter de domaine-un comme une compilation de dépendance comme vous l'avez suggéré:
```
compile project(':domain-a')
```
InformationsquelleAutor Bogdan Emil Mariesan
0

Utilisation de la compilation du projet':'.
Rien d'autre n'est nécessaire. Maintenant, votre "aide' projet ce projet partagé sur votre système de fichiers/Eclipse/IntelliJ.

InformationsquelleAutor Apurva Singh

Vous devez vous connecter pour publier un commentaire.