Android studio, gradle et NDK
Je suis très nouveau dans cette catégorie et dans le support d'Android Studio. J'ai réussi à convertir mon projet Android en dégradé à l'aide de l'option d'exportation.
Mais je suis à la recherche de documentation ou de point de départ sur la manière d’intégrer la compilation NDK au processus de construction de Gradle.
Si possible, j'ai également besoin d'une sorte d'étape "après" qui copie les fichiers binaires de construction (fichiers .so) dans le répertoire des ressources.
Nous avons publié une première version de l'intégration en tant qu'aperçu en version 1.3: http://tools.Android.com/tech-docs/Android-ndk-preview
L'intégration restera un aperçu même lorsque la version 1.3 deviendra définitive. Aucun ETA actuel quant au moment où il sera définitif (à partir du 2015/07/10).
Plus d'informations ici: http://tools.Android.com/tech-docs/Android-ndk-preview
UPDATE: Android Studio avec le support NDK est disponible: http://tools.Android.com/tech-docs/Android-ndk-preview
Pour construire avec un script, la solution gradle ci-dessous devrait fonctionner:
J'utilise mon script de construction et l'ajoute à mon fichier (semble fonctionner pour 0.8+): cela semble être équivalent à la solution ci-dessous (mais cela 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 aucun fichier .so.
Avec la mise à jour d'Android Studio à 1.0, la prise en charge de la chaîne d'outils NDK s'est considérablement améliorée (note: lisez mes mises à jour au bas de cet article pour voir l'utilisation du nouveau plugin expérimental Gradle et d'Android Studio 1.5).
Android Studio et le NDK sont suffisamment bien intégrés pour que vous ayez juste besoin de créer un bloc ndk {} dans le fichier build.gradle de votre module et de définir vos fichiers source dans le répertoire (module)/src/main/jni - et vous êtes prêt. terminé!
Pas plus ndk-build à partir de la ligne de commande.
J'ai tout écrit à ce sujet dans mon article de blog ici: http://www.sureshjoshi.com/mobile/Android-ndk-in-Android-studio-with-swig/
Les points saillants sont:
Il y a deux choses que vous devez savoir ici. Par défaut, si vous avez chargé des bibliothèques externes dans l'application Android, elles sont recherchées par défaut dans (module)/src/main/jniLibs. Vous pouvez changer cela en utilisant la définition de sourceSets.main.jniLibs.srcDirs dans le fichier build.gradle de votre module. Vous aurez besoin d’un sous-répertoire avec des bibliothèques pour chaque architecture que vous ciblez (par exemple, x86, arm, mips, arm64-v8a, etc.).
Le code que vous voulez compiler par défaut avec la chaîne d’outils NDK se trouvera dans (module)/src/main/jni et vous pourrez le modifier de la même manière que précédemment, en définissant sourceSets.main.jni.srcDirs dans le build.gradle de votre module.
et mettez ceci dans le build.gradle de votre module:
ndk {
moduleName "SeePlusPlus" // Name of C++ module (i.e. libSeePlusPlus)
cFlags "-std=c++11 -fexceptions" // Add provisions to allow C++11 functionality
stl "gnustl_shared" // Which STL library to use: gnustl or stlport
}
C'est le processus de compilation de votre code C++, à partir de là, vous devez le charger et créer des wrappers - mais à en juger par votre question, vous savez déjà comment faire tout cela, je ne vais donc pas recommencer.
Aussi, j'ai placé un repo Github de cet exemple ici: http://github.com/sureshjoshi/Android-ndk-swig-example
MISE À JOUR: 14 juin 2015
À la sortie d’Android Studio 1.3, le support du C++ via le plugin JetBrains CLion devrait être amélioré. Je suppose actuellement que cela permettra le développement en Java et C++ à partir d’Android Studio; Cependant, je pense que nous aurons toujours besoin d'utiliser la section Gradle NDK, comme je l'ai indiqué ci-dessus. De plus, je pense qu'il sera toujours nécessaire d'écrire des fichiers wrapper Java <-> C++, à moins que CLion ne les fasse automatiquement.
MISE À JOUR: 5 janvier 2016
J'ai mis à jour mon blog et le référentiel Github (dans la branche develop) pour utiliser Android Studio 1.5 avec le dernier plugin expérimental Gradle (0.6.0-alpha3).
http://www.sureshjoshi.com/mobile/Android-ndk-in-Android-studio-with-swig/http://github.com/sureshjoshi/Android-ndk-swig -Exemple
La construction de Gradle pour la section NDK ressemble maintenant à ceci:
Android.ndk {
moduleName = "SeePlusPlus" // Name of C++ module (i.e. libSeePlusPlus)
cppFlags.add("-std=c++11") // Add provisions to allow C++11 functionality
cppFlags.add("-fexceptions")
stl = "gnustl_shared" // Which STL library to use: gnustl or stlport
}
De plus, Android Studio a automatiquement complété pour les wrappers générés par C++ - Java utilisant le mot clé 'native':
Cependant, ce n'est pas tout à fait rose ... Si vous utilisez SWIG pour encapsuler une bibliothèque afin de générer automatiquement du code, puis que vous essayez d'utiliser la génération automatique de mots clés natifs, le code sera placé au mauvais endroit dans Swig _wrap. Fichier .cxx ... Vous devez donc le déplacer dans le bloc "extern C":
MISE À JOUR: 15 octobre 2017
Je m'en voudrais de ne pas mentionner qu'Android Studio 2.2 a par la suite un support essentiellement «natif» (sans jeu de mots) pour la chaîne d'outils NDK via Gradle et CMake. Désormais, lorsque vous créez un nouveau projet, sélectionnez simplement le support C++ et vous êtes prêt à partir.
Vous aurez toujours besoin de générer votre propre code de couche JNI ou d'utiliser la technique SWIG susmentionnée, mais l'échafaudage d'un projet C++ dans un projet Android est désormais trivial.
Les modifications apportées au fichier CMakeLists (où vous placez vos fichiers source C++) seront récupérées par Android Studio et seront automatiquement recompilées par toutes les bibliothèques associées.
Dans Google IO 2015, Google a annoncé l'intégration complète de NDK dans Android Studio 1.3.
Il est maintenant hors aperçu et disponible pour tout le monde: https://developer.Android.com/studio/projects/add-native-code.html
Ancienne réponse: Gradle appelle automatiquement ndk-build si vous avez un répertoire jni dans les sources de votre projet.
Cela fonctionne sur le studio Android 0.5.9 (canary build).
- Télécharger le NDK
- Ajoutez
Android_NDK_HOMEà vos variables d’environnement ou ajoutezndk.dir=/path/to/ndkà votrelocal.propertiesdans votre projet Android Studio. Cela permet à Android studio d'exécuter le ndk automatiquement. - Téléchargez les exemples de projets latest gradle pour voir un exemple de projet ndk. (Ils sont au bas de la page). Un bon exemple de projet est
ndkJniLib. Copiez le
gradle.buildà partir des exemples de projets NDK. Ça va ressembler à quelque chose comme ça. Cegradle.buildcrée un apk différent pour chaque architecture. Vous devez sélectionner l’architecture souhaitée à l’aide du voletbuild variants.![build variants pane]()
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 cela ignorera vos fichiers Android.mk et Application.mk. En guise de solution de contournement, vous pouvez demander à gradle de désactiver l'appel automatisé ndk-build, puis de spécifier le répertoire pour les sources ndk manuellement.
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
}
De plus, vous voudrez probablement appeler ndk-build dans votre script de construction de dégradé de manière explicite, 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
}
J'ai trouvé "gradle 1.11 com.Android.tools.build:gradle:0.9.+" supportant les pré-builds ndk maintenant, vous pouvez simplement mettre le * .so dans le répertoire src/main/jniLibs ..__ emballer le ndk au bon endroit.
voici mon projet
Projet: | --Src | - | --main | - | - | --Java | - | - | --jniLibs | - | - | - | --armeabi | - | - | - | - | -. so fichiers | --libs | - | - -autre.jar
Comme Xavier a dit, vous pouvez mettre vos prebuilts dans/src/main/jniLibs/si vous utilisez gradle 0.7.2+
extrait de: https://groups.google.com/d/msg/adt-dev/nQobKd2Gl_8/ctDp9viWaxoJ
Pour l'instant (Android Studio v0.8.6), c'est assez simple. Voici les étapes à suivre pour créer une application de type "Hello world":
Téléchargez le NDK Android et mettez le dossier racine à un endroit sûr - au même endroit que le dossier SDK, peut-être.
Ajoutez les éléments suivants à votre fichier
local.properties:ndk.dir=<path-to-ndk>Ajoutez les éléments suivants à votre fichier build.gradle dans la fermeture
defaultConfig, juste après la ligneversionName:ndk { moduleName="hello-world" }Dans le répertoire
mainde votre module d'application, créez un nouveau dossier appeléjni.Dans ce dossier, créez un fichier appelé
hello-world.c, que vous verrez ci-dessous.Consultez l'exemple de code
Activityci-dessous pour obtenir un exemple sur la façon d'appeler une méthode (ou s'agit-il d'une fonction?) Danshello-world.c.
hello-world.c
#include <string.h>
#include <jni.h>
jstring
Java_me_mattlogan_ndktest_MainActivity_stringFromJNI(JNIEnv* env, jobject thiz)
{
return (*env)->NewStringUTF(env, "Hello world!");
}
MainActivity.Java
public class MainActivity extends Activity {
static {
System.loadLibrary("hello-world");
}
public native String stringFromJNI();
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
String testString = stringFromJNI();
TextView mainText = (TextView) findViewById(R.id.main_text);
mainText.setText(testString);
}
}
build.gradle
apply plugin: 'com.Android.application'
Android {
compileSdkVersion 20
buildToolsVersion "20.0.0"
defaultConfig {
applicationId "me.mattlogan.ndktest"
minSdkVersion 15
targetSdkVersion 20
versionCode 1
versionName "1.0"
ndk {
moduleName "hello-world"
}
}
buildTypes {
release {
runProguard false
proguardFiles getDefaultProguardFile('proguard-Android.txt'), 'proguard-rules.pro'
}
}
}
dependencies {
compile fileTree(dir: 'libs', include: ['*.jar'])
}
Trouvez le code source complet d'une application très similaire ici (sans le NDK).
Si vous êtes sous unix, la dernière version (0.8) ajoute ndk-build. Voici comment l'ajouter:
Android.ndk {
moduleName "libraw"
}
Il s'attend à trouver le JNI sous 'src/main/jni', sinon vous pouvez le définir avec:
sourceSets.main {
jni.srcDirs = 'path'
}
À partir du 28 janvier 2014 avec la version 0.8, la construction est interrompue sous Windows, vous devez la désactiver avec:
sourceSets.main {
jni.srcDirs = [] //disable automatic ndk-build call (currently broken for windows)
}
Une solution de contournement élégante est présentée dans https://groups.google.com/d/msg/adt-dev/nQobKd2Gl_8/Z5yWAvCh4h4J .
Fondamentalement, vous créez un fichier jar contenant "lib/armeabi/yourlib.so", puis vous l'incluez dans la construction.
La réponse de @plaisthos est apparue dans la dernière version de Gradle, mais il existe toujours un moyen de le faire . Créez un répertoire native-libs à la racine du répertoire de votre projet et copiez toutes vos bibliothèques dans ce répertoire.
Ajoutez les lignes suivantes à votre build.gradle. Construis et sois heureux.
task copyNativeLibs(type: Copy) {
from(new File(project(':<your project>').getProjectDir(), 'native-libs')) { include '**/*.so' }
into new File(buildDir, 'native-libs')
}
tasks.withType(Compile) { compileTask -> compileTask.dependsOn copyNativeLibs }
clean.dependsOn 'cleanCopyNativeLibs'
Une bonne réponse pour automatiser le packaging des fichiers .so- facilement compilés est donnée dans un autre thread (fermé) . Pour que cela fonctionne, je devais changer de ligne:
from fileTree(dir: 'libs', include: '**/*.so')
dans:
from fileTree(dir: 'src/main/libs', include: '**/*.so')
Sans cette modification, les fichiers .so étaient introuvables et la tâche de leur conditionnement ne serait donc jamais exécutée.
C’est le code que j’utilise pour construire avec Android-ndk de Gradle. Pour cela, ajoutez le chemin du répertoire ndk dans gradle.properties ie. ajoutez ndkdir=/home/user/Android-ndk-r9d et mettez tous les fichiers jni dans un dossier native dans src/main/ comme vous pouvez le voir à partir du code affiché ci-dessous. Il créera un fichier jar avec des bibliothèques natives que vous pourrez utiliser normalement comme dans System.loadLibrary("libraryname");
dependencies {
compile fileTree(dir: "$buildDir/native-libs", include: '*.jar')
}
task ndkBuild(type: Exec) {
commandLine "$ndkdir/ndk-build", "--directory", "$projectDir/src/main/native", '-j', Runtime.runtime.availableProcessors(),
"APP_PLATFORM=Android-8",
"APP_BUILD_SCRIPT=$projectDir/src/main/native/Android.mk",
"NDK_OUT=$buildDir/native/obj",
"NDK_APP_DST_DIR=$buildDir/native/libs/\$(TARGET_Arch_ABI)"
}
task nativeLibsToJar(type: Jar, description: 'create a jar with native libs') {
destinationDir file("$buildDir/native-libs")
baseName 'native-libs'
from fileTree(dir: "$buildDir/native/libs", include: '**/*.so')
into 'lib/'
}
tasks.withType(JavaCompile) {
compileTask -> compileTask.dependsOn nativeLibsToJar
}
nativeLibsToJar.dependsOn 'ndkBuild'
J'ai utilisé le code suivant pour compiler les bibliothèques natives de Dropbox, j'utilise Android Studio v1.1.
task nativeLibsToJar(type: Zip) {
destinationDir file("$buildDir/native-libs")
baseName 'native-libs'
extension 'jar'
from fileTree(dir: 'src/main/libs', include: '**/*.so')
into 'lib/'
}
tasks.withType(JavaCompile) {
compileTask -> compileTask.dependsOn(nativeLibsToJar)
}
J'ai utilisé ndk.dir=/usr/shareData/Android-ndk-r11b/ chemin de ndk
dans le fichier _/local.properties du projet de studio Android. et ajoutez cette ligne:
Android.useDeprecatedNdk=true
dans le fichier gradle.properties du projet de studio Android.
Plus d'informations ici: http://tools.Android.com/tech-docs/Android-ndk-preview
NDK construit et gradé (base)
Généralement, construire avec le NDK est aussi simple que spécifier correctement un chemin ndkBuild vers Android.mk ou un chemin cmake vers CMakeLists.txt. Je recommande CMake à l'ancien Android.mk, car la prise en charge de C/C++ d'Android Studio est basée sur CLion et utilise CMake comme format de projet. D'après mon expérience, cela a eu tendance à rendre IDE plus réactif pour les projets plus importants. Tout ce qui est compilé dans votre projet sera construit et copié automatiquement dans l'APK.
apply plugin: 'com.Android.library'
Android {
compileSdkVersion 19
buildToolsVersion "25.0.2"
defaultConfig {
minSdkVersion 19
targetSdkVersion 19
ndk {
abiFilters 'armeabi', 'armeabi-v7a', 'x86'
// 64-bit support requires an Android API level higher than 19; Namely 21 and higher
//abiFilters 'armeabi', 'armeabi-v7a', 'arm64-v8a', 'x86', 'x86_64'
}
externalNativeBuild {
cmake {
arguments '-DANDROID_TOOLCHAIN=clang',
'-DANDROID_PLATFORM=Android-19',
'-DANDROID_STL=gnustl_static',
'-DANDROID_ARM_NEON=TRUE'
}
}
}
externalNativeBuild {
cmake {
path 'src/main/jni/CMakeLists.txt'
}
}
}
dependencies {
compile fileTree(dir: 'libs', include: ['*.jar'])
}
Ajout de bibliothèques prédéfinies au projet (avancé)
Les bibliothèques statiques (.a) de votre compilation NDK seront automatiquement incluses, mais les bibliothèques dynamiques prédéfinies (.so) devront être placées dans jniLibs. Cela peut être configuré avec sourceSets, mais vous devriez adopter la norme. Vous N'AVEZ PAS BESOIN de commandes supplémentaires dans build.gradle lorsque vous incluez des bibliothèques prédéfinies.
La disposition de jniLibs
Vous trouverez plus d'informations sur la structure dans le Guide de l'utilisateur du plugin Android Gradle .
|--app: |--|--build.gradle |--|--src: |--|--|--main |--|--|--|--Java |--|--|--|--jni |--|--|--|--|--CMakeLists.txt |--|--|--|--jniLibs |--|--|--|--|--armeabi |--|--|--|--|--|--.so Files |--|--|--|--|--armeabi-v7a |--|--|--|--|--|--.so Files |--|--|--|--|--x86 |--|--|--|--|--|--.so Files
Vous pouvez ensuite valider le fichier APK résultant contenant vos fichiers .so, généralement sous build/outputs/apk/, en utilisant unzip -l myApp.apk pour en répertorier le contenu.
Construire des bibliothèques partagées
Si vous construisez une bibliothèque partagée dans le NDK, vous n'avez rien d'autre à faire. Il sera correctement groupé dans l'APK.
Maintenant qu'Android Studio est sur le canal stable, il est assez simple de lancer les échantillons Android-ndk . Ces exemples utilisent le plugin expérimental ndk et sont plus récents que ceux liés à la documentation en ligne Android NDK. Une fois que vous savez qu'ils fonctionnent, vous pouvez étudier les fichiers build.gradle, local.properties et gradle-wrapper.properties et modifier votre projet en conséquence. Voici les étapes pour les faire fonctionner.
Accédez aux paramètres, Apparence et comportement, Paramètres système, SDK Android, sélectionnez l'onglet Outils du SDK, puis cochez Android NDK version 1.0.0 au bas de la liste. Cela téléchargera le NDK.
Pointez sur l'emplacement du NDK nouvellement téléchargé. Notez qu'il sera placé dans le répertoire sdk/ndk-bundle. Pour ce faire, sélectionnez Fichier, Structure du projet, Emplacement du SDK (à gauche) et indiquez un chemin sous l’emplacement du NDK Android. Cela ajoutera une entrée ndk à local.properties semblable à ceci:
Mac/Linux: ndk.dir =/Android/sdk/ndk-bundle
Windows: ndk.dir = C:\Android\sdk\ndk-bundle
J'ai construit et déployé avec succès tous les projets du référentiel de cette manière, à l'exception de gles3gni, du codec natif et du générateur. J'utilise les éléments suivants:
Android Studio 1.3 build AI-141.2117773
Exemples Android-ndk publiés le 28 juillet 2015 (lien ci-dessus)
Outils du SDK 24.3.3
NDK r10e extrait dans C:\Android\sdk\ndk-bundle
Gradle 2.5
Gradle plugin 0.2.0
Windows 8.1 64 bits
configurer le projet dans Android studio à partir d'Eclipse: vous devez importer le projet Eclipse ndk dans Android studio sans exporter dans Gradle et cela fonctionne. Vous devez également ajouter le chemin d'accès de ndk dans local.properties. puis ajouter
sourceSets.main {
jniLibs.srcDir 'src/main/libs'
jni.srcDirs = [] //disable automatic ndk-build callenter code here
}
dans le fichier build.gradle puis créez le dossier et le fichier jni à l'aide du terminal et exécutez-le.
Pour approfondir ce que Naxos a dit (merci Naxos de m'avoir envoyé dans la bonne direction!), J'ai beaucoup appris des exemples récemment publiés de NDK et j'ai posté une réponse à une question similaire ici.
Comment configurer NDK avec le plugin Android Gradle 0.7
Cet article contient des informations complètes sur la liaison des bibliothèques natives prédéfinies dans votre application pour les différentes architectures, ainsi que des informations sur la manière d'ajouter le support NDK directement au script build.gradle. Pour la plupart, vous ne devriez plus avoir besoin de travailler avec Zip et copier plus.
Voici les étapes à suivre pour que NDK fonctionne dans mon projet Android Studio . J'ai utilisé ce tutoriel pour m'aider https://software.intel.com/en-us/videos/ utilisant-le-ndk-avec-Android-studio
Pour utiliser NDK, vous devez ajouter une ligne NDK à local.properties. Donc, sous votre sdk.dir ajouter
ndk.dir=C\:\\MyPathToMyNDK\ndk
Dans mes applications build.gradle j'ai le code suivant
ndk {
moduleName "myLib"
ldLibs "log"
stl "gnustl_shared"
cFlags "-std=c++11 -frtti -fexceptions -pthread"
}
nomModule est le nom que vous souhaitez donner à votre code natif. Je crois que c'est ainsi que s'appellera la bibliothèque partagée. ldLibs me permet de me connecter à LogCat, stl est la stl que vous souhaitez importer. Il existe de nombreuses options, identiques à celles du NDK Eclipse. ( http://www.kandroid.org/ndk/docs/CPLUSPLUS-SUPPORT.html )
les drapeaux sont encore pour moi une certaine quantité de magie noire. Je n'ai pas trouvé de bonne source pour toutes les options et ce qu'elles me donnent. Cherchez autour de StackOverflow pour tout ce dont vous avez besoin, c'est là que je l'ai trouvé. Je sais que le c ++ 11 me permet d’utiliser le nouveau standard c ++ 11.
Voici un exemple de la façon dont je me connecte à LogCat à partir du code natif
__Android_log_print(Android_LOG_DEBUG, "TestApp", "Adding - String %d has a field name of %s and a value of %s", i, lKeyUTF8.c_str(), lValueUTF8.c_str());
Ajoutez simplement ces lignes à l'application build.gradle
dependencies {
...
compile fileTree(dir: "$buildDir/native-libs", include: 'native-libs.jar')
}
task nativeLibsToJar(type: Zip, description: 'create a jar archive of the native libs') {
destinationDir file("$buildDir/native-libs")
baseName 'native-libs'
extension 'jar'
from fileTree(dir: 'libs', include: '**/*.so')
into 'lib/armeabi/'
}
tasks.withType(JavaCompile) {
compileTask -> compileTask.dependsOn(nativeLibsToJar)
}
Si votre projet est exporté depuis Eclipse, ajoutez les codes ci-dessous dans un fichier de gradation:
Android { sourceSets{ main{ jniLibs.srcDir['libs'] } } }
2.Si vous créez un projet dans Android Studio:
créez un dossier nommé jniLibs dans src/main/， et placez vos fichiers * .so dans le dossier jniLibs.
Et copiez le code ci-dessous dans votre fichier de classement:
Android {
sourceSets{
main{
jniLibs.srcDir['jniLibs']
}
}
}
Bien que je pense que SJoshi (le type Oracle) a la réponse la plus complète, le projet SWIG est un cas particulier, intéressant et utile, mais pas généralisé pour la majorité des projets qui ont bien fonctionné avec les projets standard basés sur SDK ant + NDK. Nous aimerions tous utiliser le studio Android le plus probablement maintenant, ou nous voulons une chaîne d’outils de construction plus conviviale pour CI, que Gradle propose théoriquement.
J'ai posté mon approche, empruntée quelque part (j'ai trouvé cela sur SO, mais j'ai posté un Gist pour l'application build.gradle: https://Gist.github.com/truedat101/c45ff2b69e91d5c8e9c7962d4b96e841 ). En résumé, je recommande ce qui suit:
- N'améliorez pas votre projet avec la dernière version de Gradle
- Utilisez com.Android.tools.build:gradle:1.5.0 dans la racine de votre projet
- Utilisez com.Android.application dans votre projet d'application
- Assurez-vous que gradle.properties a: Android.useDeprecatedNdk = true (au cas où il se plaint)
- Utilisez l'approche ci-dessus pour vous assurer que vos heures et vos heures d'efforts pour créer des fichiers Android.mk ne seront pas perdues. Vous contrôlez les cibles Arch (s) à construire. Et ces instructions sont bienveillantes pour les utilisateurs Windows, qui devraient théoriquement être capables de construire sur Windows sans problèmes particuliers.
Gradle pour Android a été un désastre à mon avis, tout comme j'aime bien les concepts empruntés et la structure de répertoires pour un projet. Cette fonctionnalité NDK est "à venir" depuis près de 3 ans.