web-dev-qa-db-fra.com

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

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 Android projets d'application et 1 Android projet de bibliothèque). Les 2 projets d'application dépendent du projet de bibliothèque. Lorsque 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 dont cela devrait être fait.

Existe-t-il un moyen de faire en sorte que les 3 projets exportés par Eclipse fonctionnent ensemble? Suis-je mieux de restructurer les choses et si oui, est-ce que la documentation explique comment cela devrait être fait?

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éez un nouveau projet appelé MyApp
  2. Cliquez sur File > New Module, choisissez Android Library et nommez-le MyLib.
  3. Cliquez 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 attribut package au manifeste, le rendant

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

Après avoir construit, 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 dépendance ne semble pas avoir d'impact sur l'erreur. En continuant d'en haut

  1. Cliquez 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 OK
  5. Cliquez Build > Make Project

Mise à jour 2

Sur la base des suggestions d'Ethan c'est là que nous obtenons

Les 2 sous-projets build.gradle semblent avoir toutes les pièces correctes et la seule différence est que la ligne de plug-in ci-dessous est le 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 racine build.gradle était vide, j'ai donc ajouté les deux projets comme celui-ci.

dependencies {
    compile project(":MyLib")
    compile 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 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 résoudre ce problème.

  1. Ajouter compile project(':SubProjects:MyLib') au MyLib/build.gradle
  2. Supprimer compile files('libs/Android-support-v4.jar') du MyLib/build.gradle
  3. Fermer le projet et importer le projet racine depuis gradle

Mise à jour 4

À partir de la version 0.1.2, vous pouvez désormais inclure compile "com.Android.support:support-v4:13.0.0" au lieu de compile files('libs/Android-support-v4.jar'). Puisqu'il vient de mavin maintenant, vous pouvez l'inclure dans plusieurs projets sans problèmes.

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

Depuis la version 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.

androidgradleandroid-studio
143
respectTheCode

Remarque : Cette réponse est une pure réponse de Gradle. Je l'utilise régulièrement dans IntelliJ mais je ne sais pas comment se déroule l'intégration avec Android Studio. Je suis convaincu de savoir ce qui se passe pour moi. C’est ainsi que 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, un 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 n'avez qu'un projet, le fichier settings.gradle n'est pas nécessaire. Cependant, vous souhaitez ajouter plus de projets, nous en avons donc besoin.

Jetons maintenant un coup d'œil à ce fichier build.gradle. Vous allez en avoir besoin (pour ajouter les outils Android)

build.gradle 

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

Nous devons maintenant informer Gradle de certaines des Android parties. 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 de la version et le code 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'
}

Nous avons maintenant un projet à construire. Nous allons maintenant ajouter les autres. Je les mets dans un répertoire, peut-être l'appelle deps, ou sous-projets. Cela n'a pas vraiment d'importance, mais vous aurez besoin de savoir où vous le mettez. Pour indiquer à Gradle où sont les projets, vous devez 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 que vous devez vérifier est le sous-projet /reallyCoolProject1/build.gradle a apply plugin: "Android-library" au lieu de 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 normales Java souhaitées.

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 le faites une ou deux fois. De cette façon, vous pourrez également utiliser un serveur CI en supposant que le SDK Android y soit installé.

Remarque sur le côté de NDK: Si vous souhaitez utiliser le NDK, vous aurez besoin de quelque chose comme ci-dessous. Vous trouverez un exemple de fichier build.gradle ici: https://Gist.github.com/khernyo/422692

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/422692
  3. https://github.com/ethankhall/driving-time-tracker/
115
Ethan

Je viens d'avoir un problème très similaire avec gradle builds/ajout de la bibliothèque .jar. Je l'ai obtenu en combinant:

  1. Déplacement du dossier libs vers la racine du projet (même répertoire que "src") et ajout de la bibliothèque à ce dossier dans le Finder (avec 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. Modification des dépendances dans le fichier build.gradle en ajoutant compile fileTree(dir: 'libs', include: '*.jar')}

MAIS plus important et ennuyeux, quelques heures à peine après le début du travail, Android Studio vient de publier la version 0.3.7, qui affirme avoir résolu de nombreux problèmes de classement, tels que l'ajout de bibliothèques .jar.

http://tools.Android.com/recent

J'espère que cela aide les gens!

6
Joel Balmer

Voici ma solution pour les utilisateurs de Mac. Je pense que cela fonctionne également pour Windows:

Allez d’abord dans la barre d’outils Android Studio

Construire> Créer un projet (pendant que vous êtes en ligne, laissez-le télécharger les fichiers), puis

Build> Compile Module "le nom de votre application est affiché ici" (toujours en ligne, laissez les fichiers
télécharger et terminer) puis

Lancez votre application, lancez votre émulateur, configurez-le puis lancez-le!

C'est ça!!! Bonne codage les gars !!!!!!!

1
Henula

Gradle Build Tools 2.2.0+ - Tout fonctionne

C'est la bonne façon de le faire

En essayant d'éviter les expérimentations et franchement marre du NDK et de tout son hackery, je suis heureux que la version 2.2.x de Gradle Build Tools soit sortie et qu'elle fonctionne maintenant. La clé est la externalNativeBuild et pointe ndkBuild argument de chemin sur un Android.mk ou change ndkBuild en cmake et pointe l'argument de chemin à un CMakeLists.txt construire un 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 cela est configuré correctement, vous pouvez ./gradlew installDebug et vous pouvez partir. Vous devez également savoir que le NDK passe à clang, car gcc est maintenant obsolète dans le Android NDK.

0
Cameron Lowell Palmer