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

Question

J'essaie de migrer un projet depuis Eclipse mais rien de ce que j'ai essayé ne fonctionne. 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. Lorsque je fais l'exportation gradle, j'obtiens 3 projets qui ne fonctionnent pas. Je suis prêt à restructurer le projet mais je n'ai pas trouvé de documentation sur la manière de procéder.

Existe-t-il un moyen de faire fonctionner ensemble les 3 projets qu'Eclipse exporte ? Vaut-il mieux que je restructure les choses et si oui, existe-t-il une documentation sur la manière de procéder ?

Mise à jour

J'ai téléchargé l'ensemble du projet sur GitHub. https://github.com/respectTheCode/Android-studio-library-example

Mise à jour 1

Sur la base des suggestions de Padma Kumar, voici ce que j'ai essayé.

1. Créez un nouveau projet appelé MyApp
2. Cliquez sur File > New Module choisissez Android Library et le nommer 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: <manifest> does not have package attribute.

J'ai ensuite ajouté un package au manifeste en le rendant

<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.example.mylib" >

Après la construction, j'obtiens 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 la dépendance ne semble pas avoir d'impact sur l'erreur. En continuant à partir de ce qui précède

1. Cliquez sur File > Project Structure > Modules > MyApp-MyApp
2. Passer à Dependencies Onglet
3. Cliquez sur + > Module Dependency et choisir MyLib
4. Cliquez sur Apply y OK
5. Cliquez sur Build > Make Project

Mise à jour 2

En se basant sur les suggestions d'Ethan, voici ce que nous obtenons

Les 2 sous-projets build.gradle semble avoir toutes les pièces correctes et la seule différence est la ligne de plugin 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 {
    compile files('libs/android-support-v4.jar')
}

android {
    compileSdkVersion 17
    buildToolsVersion "17.0.0"

    defaultConfig {
        minSdkVersion 7
        targetSdkVersion 16
    }
}

Le projet Root build.gradle était vide, j'ai donc ajouté les deux projets comme ceci

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

J'obtiens 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 compile() 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

Grand merci Ethan pour avoir résolu ce problème.

1. Ajouter compile project(':SubProjects:MyLib') à la MyLib/build.gradle
2. Retirer compile files('libs/android-support-v4.jar') de la MyLib/build.gradle
3. Fermez le projet et importez le projet racine depuis gradle.

Mise à jour 4

À partir de la version 0.1.2, vous pouvez désormais inclure les éléments suivants compile "com.android.support:support-v4:13.0.0" au lieu de compile files('libs/android-support-v4.jar') . Puisqu'il provient 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 {
    compile "com.android.support:support-v4:13.0.0"

    compile project(':SubProjects:MyLib')
}

Mise à jour 5

À partir de la version 0.1.3, il y a maintenant un bouton "Sync Project" dans la barre d'outils. Vous pouvez cliquer sur ce bouton au lieu de réimporter votre projet après avoir apporté des modifications à .gradle des fichiers.

Answer 1

Note : Cette réponse est une réponse purement Gradle, je l'utilise dans IntelliJ sur une base régulière, mais je ne sais pas comment l'intégration est avec Android Studio. Je suis un adepte de la connaissance de ce qui se passe pour moi, c'est donc ainsi que j'utilise Gradle et Android.

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

Avis de non-responsabilité : C'est un projet sur lequel je travaille/travaillais.

Gradle dispose d'un défini (que vous pouvez modifier, le lien en bas de page vous explique comment) qui est très similaire à Maven si vous l'avez déjà utilisé.

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 n'avez qu'un seul projet, le fichier settings.gradle n'est pas nécessaire. Cependant, vous voulez ajouter d'autres projets, alors nous en avons besoin.

Maintenant, jetons un coup d'oeil à ce fichier build.gradle. Vous aurez besoin de ceci (pour ajouter les outils Android)

build.gradle

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

Maintenant, nous devons parler à Gradle de certaines parties d'Android. C'est assez simple. Un modèle de base (qui fonctionne dans la plupart de mes cas) ressemble à ce qui suit. J'ai un commentaire dans ce bloc, il 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 {
        compileSdkVersion 17
        /*
        defaultConfig {
            versionCode = 1
            versionName = "0.0.0"
        }
        */
    }

Nous allons vouloir ajouter quelque chose, 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'
}

Donc maintenant nous avons un projet à construire. Maintenant nous allons ajouter les autres. Je les mets dans un répertoire, que je peux appeler deps, ou subProjects. Cela n'a pas vraiment d'importance, mais vous aurez besoin de savoir où vous les avez mis. Pour indiquer à Gradle où se trouvent les projets, vous allez devoir les ajouter à settings.gradle.

Structure du répertoire :

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-projets/reallyCoolProject1/build.gradle tiene apply plugin: "android-library" au lieu de apply plugin: "android" .

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

build.gradle

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

Je sais que cela semble être beaucoup d'étapes, mais elles sont assez faciles une fois que vous l'avez fait une ou deux fois. Cette méthode 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(Compile) { compileTask -> compileTask.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/

Answer 2

Je viens d'avoir un problème très similaire avec les constructions gradle / l'ajout de la bibliothèque .jar. J'ai réussi à le faire fonctionner par une combinaison de :

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

MAIS, plus important encore et plus ennuyeux, quelques heures seulement après que j'ai réussi à le faire fonctionner, Android Studio vient de publier la version 0.3.7, qui prétend avoir résolu de nombreux problèmes liés à Gradle, comme l'ajout de bibliothèques .jar.

http://tools.Android.com/recent

J'espère que cela aidera les gens !

Answer 3

Voici ma solution pour les utilisateurs de Mac, je pense qu'elle fonctionne aussi pour Windows :

Tout d'abord, allez dans votre barre d'outils Android Studio

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

Build > Compile Module "votre nom d'application est montré ici" (toujours en ligne laissez les fichiers sont
télécharger et terminer) et ensuite

Lancez votre application, c'est fait, il lancera votre émulateur et le configurera puis le lancera !

C'est tout ! !! Bon codage les gars !!!!!!!

Answer 4

Outils de construction Gradle 2.2.0+ - Tout fonctionne tout simplement

C'est la manière correcte de le faire

En essayant d'éviter les expérimentations et en ayant franchement marre du NDK et de tous ses bidouillages, je suis heureux que la version 2.2.x des outils de construction Gradle soit sortie et qu'elle fonctionne désormais. La clé est le externalNativeBuild et pointant ndkBuild l'argument du chemin à un Android.mk ou de changer ndkBuild a cmake et faire pointer l'argument du chemin vers un CMakeLists.txt construire script.

android {
    compileSdkVersion 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 Page de Google sur l'ajout de code natif .

Une fois que tout est correctement configuré, vous pouvez ./gradlew installDebug et c'est parti. Vous devez également savoir que le NDK passe à clang puisque gcc est désormais déprécié dans le NDK Android.