Comment construire une bibliothèque Android avec Android Studio et graduer?

J’essaie de migrer un projet depuis Eclipse mais rien n’a fonctionné. Dans Eclipse, j’ai 3 projets (2 projets d’application Android et 1 projet de bibliothèque Android). Les 2 projets d’application dépendent du projet de bibliothèque. Quand je fais l’exportation, je reçois 3 projets qui ne fonctionnent pas. Je suis ouvert à la restructuration du projet mais je n’ai trouvé aucune documentation sur la manière de le faire.

Existe-t-il un moyen de faire fonctionner les 3 projets exportés par Eclipse? Est-il préférable de restructurer les choses et si oui, de la documentation sur la manière de procéder?

Mettre à jour

J’ai téléchargé l’intégralité du projet sur GitHub https://github.com/respectTheCode/android-studio-library-example

Mise à jour 1

Sur la base des suggestions de Padma Kumar, c’est ce que j’ai essayé.

  1. Créer un nouveau projet appelé MyApp
  2. Cliquez sur File > New Module , choisissez Android Library et nommez-le MyLib
  3. Cliquez sur Build > Make Project

La construction échoue avec cette erreur

 Module "MyLib" was fully rebuilt due to project configuration/dependencies changes Compilation completed with 1 error and 0 warnings in 19 sec 1 error 0 warnings /.../MyApp/MyLib/build/bundles/debug/AndroidManifest.xml Gradle:  does not have package atsortingbute. 

J’ai ensuite ajouté un atsortingbut de package au manifeste le rendant

  

Après la construction, je reçois cette erreur

 Module "MyApp" was fully rebuilt due to project configuration/dependencies changes Compilation completed with 2 errors and 0 warnings in 13 sec 2 errors 0 warnings /.../MyApp/MyLib/src/main/java/com/example/mylib/MainActivity.java Gradle: package R does not exist Gradle: package R does not exist 

L’ajout de dépendance ne semble pas avoir d’impact sur l’erreur. En continuant d’en haut

  1. Cliquez sur File > Project Structure > Modules > MyApp-MyApp
  2. Passer à l’onglet Dependencies
  3. Cliquez sur + > Module Dependency et sélectionnez MyLib
  4. Cliquez sur Apply et sur OK
  5. Cliquez sur Build > Make Project

Mise à jour 2

Sur la base des suggestions d’Ethan, c’est ici que nous obtenons

Les 2 sous-projets build.gradle semblent avoir toutes les parties correctes et la seule différence est que la ligne de plug-in ci-dessous est la MyApp/build.gradle .

 buildscript { repositories { maven { url 'http://repo1.maven.org/maven2' } } dependencies { classpath 'com.android.tools.build:gradle:0.4' } } apply plugin: 'android' dependencies { comstack files('libs/android-support-v4.jar') } android { comstackSdkVersion 17 buildToolsVersion "17.0.0" defaultConfig { minSdkVersion 7 targetSdkVersion 16 } } 

Le projet racine build.gradle était vide alors j’ai ajouté les deux projets comme celui-ci

 dependencies { comstack project(":MyLib") comstack project(":MyApp") } 

Je reçois maintenant cette erreur lors de la construction

 Gradle: FAILURE: Build failed with an exception. * Where: Build file '/Users/kevin/GitHub/AppPress/MyApp/build.gradle' line: 2 * What went wrong: A problem occurred evaluating root project 'MyApp'. > Could not find method comstack() for arguments [project ':MyLib'] on root project 'MyApp'. * Try: Run with --stacktrace option to get the stack trace. Run with --info or --debug option to get more log output. 

Mise à jour 3

Merci à Ethan d’avoir résolu ce problème.

  1. Ajouter un comstack project(':SubProjects:MyLib') à MyLib/build.gradle
  2. Supprimer les comstack files('libs/android-support-v4.jar') du MyLib/build.gradle
  3. Fermer le projet et importer le projet racine de gradle

Mise à jour 4

A partir de la version 0.1.2, vous pouvez maintenant inclure la comstack "com.android.support:support-v4:13.0.0" au lieu des comstack files('libs/android-support-v4.jar') de comstack files('libs/android-support-v4.jar') . Comme il vient de mavin, vous pouvez l’inclure dans plusieurs projets sans problème.

 buildscript { repositories { mavenCentral() } dependencies { classpath 'com.android.tools.build:gradle:0.4.2' } } apply plugin: 'android' dependencies { comstack "com.android.support:support-v4:13.0.0" comstack project(':SubProjects:MyLib') } 

Mise à jour 5

À partir de 0.1.3, il y a maintenant un bouton “Synchroniser le projet” dans la barre d’outils. Vous pouvez cliquer dessus au lieu de réimporter votre projet après avoir modifié les fichiers .gradle .

Note : Cette réponse est une réponse pure de Gradle, je l’utilise régulièrement dans IntelliJ mais je ne sais pas comment l’intégration est avec Android Studio. Je suis convaincu de savoir ce qui se passe pour moi, donc voici comment j’utilise Gradle et Android.

TL; DR Exemple complet – https://github.com/ethankhall/driving-time-tracker/

Disclaimer : C’est un projet sur lequel je travaille / travaillais.

Gradle a une structure définie (que vous pouvez modifier, le lien en bas vous indique comment) qui est très similaire à Maven si vous l’avez déjà utilisée.

 Project Root +-- src | +-- main (your project) | | +-- java (where your java code goes) | | +-- res (where your res go) | | +-- assets (where your assets go) | | \-- AndroidManifest.xml | \-- instrumentTest (test project) | \-- java (where your java code goes) +-- build.gradle \-- settings.gradle 

Si vous ne disposez que d’un seul projet, le fichier settings.gradle n’est pas nécessaire. Cependant, vous souhaitez append plus de projets, nous en avons donc besoin.

Maintenant, jetons un coup d’œil à ce fichier build.gradle. Vous allez en avoir besoin (pour append les outils Android)

build.gradle

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

Maintenant, nous devons informer Gradle de certaines parties d’Android. C’est assez simple Une base (qui fonctionne dans la plupart de mes cas) ressemble à ce qui suit. J’ai un commentaire dans ce bloc, cela me permettra de spécifier le nom et le code de la version lors de la génération de l’APK.

build.gradle

 apply plugin: "android" android { comstackSdkVersion 17 /* defaultConfig { versionCode = 1 versionName = "0.0.0" } */ } 

Quelque chose que nous voulons append, pour aider ceux qui n’ont pas encore vu la lumière de Gradle, un moyen pour eux d’utiliser le projet sans l’installer.

build.gradle

 task wrapper(type: org.gradle.api.tasks.wrapper.Wrapper) { gradleVersion = '1.4' } 

Alors maintenant, nous avons un projet à construire. Maintenant, nous allons append les autres. Je les mets dans un répertoire, peut-être appelez-le deps, ou sous-projets. Cela n’a pas vraiment d’importance, mais vous devrez savoir où vous le mettez. Pour indiquer à Gradle où sont les projets, vous devrez les append aux parameters.

Structure d’annuaire:

 Project Root +-- src (see above) +-- subProjects (where projects are held) | +-- reallyCoolProject1 (your first included project) | \-- See project structure for a normal app | \-- reallyCoolProject2 (your second included project) | \-- See project structure for a normal app +-- build.gradle \-- settings.gradle 

settings.gradle:

 include ':subProjects:reallyCoolProject1' include ':subProjects:reallyCoolProject2' 

La dernière chose dont vous devez vous assurer est le sous- projet / reallyCoolProject1 / build.gradle a un apply plugin: "android-library" au lieu d’ apply plugin: "android" .

Comme tous les projets Gradle (et Maven), nous devons maintenant informer le projet racine de sa dépendance. Cela peut également inclure les dépendances Java normales que vous souhaitez.

build.gradle

 dependencies{ comstack 'com.fasterxml.jackson.core:jackson-core:2.1.4' comstack 'com.fasterxml.jackson.core:jackson-databind:2.1.4' comstack project(":subProjects:reallyCoolProject1") comstack project(':subProjects:reallyCoolProject2') } 

Je sais que cela semble beaucoup d’étapes, mais elles sont assez faciles une fois que vous le faites une ou deux fois. Cela vous permettra également de construire sur un serveur CI en supposant que le SDK Android y soit installé.

NDK Side Note: Si vous utilisez le NDK, vous aurez besoin de quelque chose comme ci-dessous. Un exemple de fichier build.gradle peut être trouvé ici: https://gist.github.com/khernyo/4226923

build.gradle

 task copyNativeLibs(type: Copy) { from fileTree(dir: 'libs', include: '**/*.so' ) into 'build/native-libs' } tasks.withType(Comstack) { comstackTask -> comstackTask.dependsOn copyNativeLibs } clean.dependsOn 'cleanCopyNativeLibs' tasks.withType(com.android.build.gradle.tasks.PackageApplication) { pkgTask -> pkgTask.jniDir new File('build/native-libs') } 

Sources:

  1. http://tools.android.com/tech-docs/new-build-system/user-guide
  2. https://gist.github.com/khernyo/4226923
  3. https://github.com/ethankhall/driving-time-tracker/

J’ai juste eu des problèmes très similaires avec les compilations gradle / l’ajout de la bibliothèque .jar. Je l’ai fait fonctionner par une combinaison de:

  1. Déplacement du dossier libs jusqu’à la racine du projet (même répertoire que ‘src’) et ajout de la bibliothèque à ce dossier dans finder (sous Mac OS X)
  2. Dans Android Studio, cliquez avec le bouton droit sur le dossier à append en tant que bibliothèque.
  3. Editer les dépendances dans le fichier build.gradle, en ajoutant comstack fileTree(dir: 'libs', include: '*.jar')}

MAIS plus important et ennuyeux, seulement quelques heures après que je l’ai fait fonctionner, Android Studio vient de sortir 0.3.7, qui prétend avoir résolu beaucoup de problèmes de gradation tels que l’ajout de bibliothèques .jar

http://tools.android.com/recent

J’espère que cela aide les gens!

Voici ma solution pour les utilisateurs de mac je pense que cela fonctionne aussi pour la fenêtre:

Accédez d’abord à votre barre d’outils Android Studio

Build> Make Project (pendant que vous êtes en ligne, laissez-le télécharger les fichiers), puis

Build> Comstack Module “le nom de votre application est affiché ici” (toujours en ligne, laissez les fichiers
télécharger et terminer) et ensuite

Exécutez votre application qui est faite, il lancera votre émulateur et le configurera, puis l’exécutera!

C’est ça!!! Heureux les gars de codage !!!!!!!

Gradle Build Tools 2.2.0+ – Tout fonctionne

C’est la bonne façon de le faire

En essayant d’éviter de façon expérimentale et franchement marre du NDK et de tous ses pirates, je suis heureux que le 2.2.x des outils de compilation de Gradle soit sorti et que ça fonctionne maintenant. La clé est le ndkBuild externalNativeBuild et le chemin ndkBuild sur un ndkBuild Android.mk ou changez ndkBuild en cmake et pointez l’argument path sur un CMakeLists.txt génération CMakeLists.txt .

 android { comstackSdkVersion 19 buildToolsVersion "25.0.2" defaultConfig { minSdkVersion 19 targetSdkVersion 19 ndk { abiFilters 'armeabi', 'armeabi-v7a', 'x86' } externalNativeBuild { cmake { cppFlags '-std=c++11' arguments '-DANDROID_TOOLCHAIN=clang', '-DANDROID_PLATFORM=android-19', '-DANDROID_STL=gnustl_static', '-DANDROID_ARM_NEON=TRUE', '-DANDROID_CPP_FEATURES=exceptions rtti' } } } externalNativeBuild { cmake { path 'src/main/jni/CMakeLists.txt' } //ndkBuild { // path 'src/main/jni/Android.mk' //} } } 

Pour plus de détails, consultez la page de Google sur l’ajout de code natif .

Une fois que cela est configuré correctement, vous pouvez ./gradlew installDebug et vous partez. Vous devrez également savoir que le NDK est en train de basculer puisque gcc est maintenant obsolète dans le NDK Android.