Android studio, gradle et NDK

Question

Je suis très novice dans l'utilisation de gradle et d'Android Studio. J'ai réussi à convertir mon projet Android en gradle en utilisant l'option d'exportation.

Mais je suis à la recherche d'une documentation ou d'un point de départ pour intégrer le build NDK dans le processus de build gradle.

Si possible, j'ai également besoin d'une sorte d'étape "après" qui copie les binaires de construction (fichiers .so) dans le répertoire des ressources.

Answer 1

Nous avons publié une première version de l'intégration en avant-première dans la version 1.3 : http://tools.Android.com/tech-docs/Android-ndk-preview

L'intégration restera en avant-première même après la version finale de la 1.3. Il n'y a pas d'ETA actuelle quant à la date à laquelle elle sera finale (en date du 2015/07/10).

Plus d'informations ici : http://tools.Android.com/tech-docs/Android-ndk-preview

Answer 2

UPDATE : L'Android Studio avec le support NDK est maintenant disponible : http://tools.Android.com/tech-docs/Android-ndk-preview

Pour la construction avec un script la solution gradle ci-dessous devrait fonctionner :

J'utilise ma construction script et ajouté à mon fichier (semble fonctionner pour 0.8+ ) : Ceci semble être équivalent à la solution ci-dessous (mais semble plus joli dans le fichier gradle) :

 android {
    sourceSets {
        main {
            jniLibs.srcDirs = ['native-libs']
            jni.srcDirs = [] //disable automatic ndk-build
        }
    }
 }

La construction n'échoue malheureusement pas si le répertoire n'est pas présent ou ne contient pas de .so des fichiers.

Answer 3

Lors de la Google IO 2015, Google a annoncé l'intégration complète du NDK dans Android Studio 1.3.

Il est désormais disponible pour tous : https://developer.Android.com/studio/projects/add-native-code.html

Vieille réponse : Gradle appelle automatiquement ndk-build si vous avez un jni dans les sources de votre projet.

Cela fonctionne sur Android studio 0.5.9 (canary build).

1. Télécharger le NDK

2. Soit ajouter ANDROID_NDK_HOME à vos variables d'environnement ou ajoutez ndk.dir=/path/to/ndk à votre local.properties dans votre projet Android Studio. Cela permet à Android studio d'exécuter le ndk automatiquement.

3. Télécharger le les derniers projets d'exemple gradle pour voir un exemple de projet ndk. (Ils se trouvent en bas de la page). Un bon exemple de projet est ndkJniLib .

4. Copiez le gradle.build à partir des projets d'exemple du NDK. Cela ressemblera à quelque chose comme ceci. Ce gradle.build crée un apk différent pour chaque architecture. Vous devez sélectionner l'architecture que vous voulez en utilisant l'option build variants volet.

   apply plugin: 'android'
   
   dependencies {
       compile project(':lib')
   }
   
   android {
       compileSdkVersion 19
       buildToolsVersion "19.0.2"
   
       // This actual the app version code. Giving ourselves 100,000 values [0, 99999]
       defaultConfig.versionCode = 123
   
       flavorDimensions "api", "abi"
   
       productFlavors {
           gingerbread {
               flavorDimension "api"
               minSdkVersion 10
               versionCode = 1
           }
           icecreamSandwich {
               flavorDimension "api"
               minSdkVersion 14
               versionCode = 2
           }
           x86 {
               flavorDimension "abi"
               ndk {
                   abiFilter "x86"
               }
               // this is the flavor part of the version code.
               // It must be higher than the arm one for devices supporting
               // both, as x86 is preferred.
               versionCode = 3
           }
           arm {
               flavorDimension "abi"
               ndk {
                   abiFilter "armeabi-v7a"
               }
               versionCode = 2
           }
           mips {
               flavorDimension "abi"
               ndk {
                   abiFilter "mips"
               }
               versionCode = 1
           }
           fat {
               flavorDimension "abi"
               // fat binary, lowest version code to be
               // the last option
               versionCode = 0
           }
       }
   
       // make per-variant version code
       applicationVariants.all { variant ->
           // get the version code of each flavor
           def apiVersion = variant.productFlavors.get(0).versionCode
           def abiVersion = variant.productFlavors.get(1).versionCode
   
           // set the composite code
           variant.mergedFlavor.versionCode = apiVersion * 1000000 + abiVersion * 100000 + defaultConfig.versionCode
       }
   
   }

Notez que cette opération ignorera vos fichiers Android.mk et Application.mk. Comme solution de rechange, vous pouvez demander à gradle de désactiver l'appel automatique à ndk-build, puis spécifier manuellement le répertoire des sources ndk.

sourceSets.main {
    jniLibs.srcDir 'src/main/libs' // use the jni .so compiled from the manual ndk-build command
    jni.srcDirs = [] //disable automatic ndk-build call
}

En outre, vous voudrez probablement appeler ndk-build dans votre gradle build script explicitement, car vous venez de désactiver l'appel automatique.

task ndkBuild(type: Exec) {
   commandLine 'ndk-build', '-C', file('src/main/jni').absolutePath
}

tasks.withType(JavaCompile) {
    compileTask -> compileTask.dependsOn ndkBuild
}

Answer 4

J'ai trouvé que "gradle 1.11 com.Android.tools.build:gradle:0.9.+" supporte la pré-construction de ndk maintenant, vous pouvez juste mettre le *.so dans le répertoire src/main/jniLibs. Lors de la construction, gradle empaquetera le ndk au bon endroit.

voici mon projet

Project:
|--src
|--|--main
|--|--|--java
|--|--|--jniLibs
|--|--|--|--armeabi
|--|--|--|--|--.so files
|--libs
|--|--other.jar

Answer 5

Comme Xavier l'a dit, vous pouvez placer vos prébuilts dans /src/main/jniLibs/ si vous utilisez gradle 0.7.2+.

tiré de : https://groups.google.com/d/msg/adt-dev/nQobKd2Gl_8/ctDp9viWaxoJ