generate - import aar android studio




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

J'essaye de migrer un projet d'Eclipse mais rien de ce que j'ai essayé ne marche. Dans Eclipse j'ai 3 projets (2 projets d'applications android et 1 projet de bibliothèque android). Les deux projets d'application dépendent du projet de bibliothèque. Quand je fais l'exportation progressive, j'ai 3 projets qui ne fonctionnent pas. Je suis ouvert à la restructuration du projet, mais je n'ai trouvé aucune documentation sur la façon dont cela devrait être fait.

Existe-t-il un moyen de faire fonctionner ensemble les 3 projets exportés par Eclipse? Suis-je préférable de restructurer les choses et, si oui, de la documentation sur la façon dont cela devrait être fait?

Mettre à 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 c'est ce que j'ai essayé.

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

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

Après la construction, j'ai 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

Ajouter une dépendance ne semble pas avoir d'impact sur l'erreur. 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 OK
  5. Cliquez sur 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 bonnes pièces et la seule différence est la ligne de plugin 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 alors j'ai 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

Un grand merci à Ethan pour avoir résolu ça.

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

Mise à jour 4

Depuis la version 0.1.2, vous pouvez maintenant compile "com.android.support:support-v4:13.0.0" au lieu de compile files('libs/android-support-v4.jar') . Comme 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 0.1.3 il y a maintenant un bouton "Sync Project" dans la barre d'outils. Vous pouvez cliquer dessus au lieu de réimporter votre projet après avoir apporté des modifications aux fichiers .gradle .


Gradle Build Tools 2.2.0+ - Tout fonctionne

C'est la bonne façon de le faire

En essayant d'éviter expérimental et franchement marre avec le NDK et tout son hackery je suis heureux que 2.2.x des outils de construction de Gradle est sorti et maintenant cela fonctionne juste. La clé est externalNativeBuild et pointe l'argument du chemin ndkBuild sur un Android.mk ou change ndkBuild pour cmake et pointe l'argument path dans un CMakeLists.txt construction CMakeLists.txt .

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 la page de Google sur l'ajout de code natif .

Après cela est configuré correctement, vous pouvez ./gradlew installDebug et c'est parti. Vous devez également savoir que le NDK passe à un clang puisque gcc est maintenant obsolète dans le NDK Android.


Je viens d'avoir des problèmes très similaires avec les builds gradle / l'ajout de la bibliothèque .jar. Je l'ai eu en travaillant par une combinaison de:

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

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

http://tools.android.com/recent

J'espère que cela aide les gens!


Note : Cette réponse est une réponse Gradle pure, je l'utilise régulièrement dans IntelliJ mais je ne sais pas comment l'intégrer avec Android Studio. Je crois en 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 travaillais.

Gradle a une structure defined (que vous pouvez changer, lien en bas vous indique 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 avez seulement un projet, le fichier settings.gradle n'est pas nécessaire. Cependant, vous voulez ajouter plus de projets, nous en avons donc besoin.

Jetons un coup d'oeil à 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'
    }
}

Maintenant, nous devons dire à Gradle certaines des pièces Android. C'est plutôt simple. Une 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 du fichier APK.

build.gradle

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

Quelque chose que nous allons vouloir ajouter, pour aider quelqu'un qui n'a 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 ajouter les autres. Je les mets dans un répertoire, peut-être appelez-les deps, ou subProjects. Cela n'a pas vraiment d'importance, mais vous aurez besoin de savoir où vous l'avez mis. Pour dire à Gradle où 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, c'est que subProjects / 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 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 ressemble à beaucoup d'étapes, mais ils sont assez faciles une fois que vous le faites une ou deux fois. De cette façon, vous pourrez également construire sur un serveur CI en supposant que vous avez installé le SDK Android.

NDK Side Note: Si vous allez utiliser le NDK, vous aurez besoin de quelque chose comme ci-dessous. 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. defined
  2. https://gist.github.com/khernyo/4226923
  3. https://github.com/ethankhall/driving-time-tracker/




android-studio