Join FlipAndroid.COM Telegram Group: https://t.me/joinchat/F_aqThGkhwcLzmI49vKAiw


Estudio de Android, gradle y NDK

Soy muy nuevo en todo este gradle y soporte para Android Studio. He conseguido convertir mi proyecto de androide a gradle usando la opción de exportación.

Pero estoy buscando alguna documentación o punto de inicio cómo integrar la compilación de NDK en el proceso de generación de gradle.

Si es posible también necesito algún tipo de etapa "después" que copie los binarios de compilación (archivos .so) en el directorio de activos.

  • Gradle se cuelga en tareas de ejecución: [: android: generateDebugSources
  • No se puede generar proyecto con minSdk = 21
  • Cómo poner mis bibliotecas delante de android.jar editando build.gradle en Android-Studio
  • Tarea personalizada de Android Gradle por variante
  • Cordova / Ionic build android Gradle error: La versión mínima de Gradle admitida es 2.14.1. La versión actual es 2.13
  • Android Studio cómo empaquetar AAR único de varios proyectos de biblioteca?
  • Edición de Kotlin Gradle
  • ¿Cómo puedo importar la biblioteca de diseño de material a Android Studio?
  • 23 Solutions collect form web for “Estudio de Android, gradle y NDK”

    Hemos lanzado una primera versión de la integración como una vista previa en 1.3: http://tools.android.com/tech-docs/android-ndk-preview

    La integración se mantendrá una vista previa incluso después de 1.3 se convierte en final. No hay ETA actual en cuanto a cuándo será final (a partir de 2015/07/10).

    Más información aquí: http://tools.android.com/tech-docs/android-ndk-preview

    ACTUALIZACIÓN: El estudio de Android con soporte para NDK ya está disponible: http://tools.android.com/tech-docs/android-ndk-preview

    Para construir con un guión, la siguiente solución gradle debería funcionar:

    Estoy utilizando mi script de construcción y agregado a mi archivo (Parece que funciona para 0.8+ ): Esto parece ser equivalente a la solución de abajo (pero se ve mejor en el archivo gradle):

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

    Desafortunadamente, la compilación no falla si el directorio no está presente o no contiene archivos .so .

    Con la actualización de Android Studio a 1.0, la ayuda de la cadena de herramientas de NDK mejoró inmensamente ( nota: por favor lea mis actualizaciones en la parte inferior de este post para ver el uso con el nuevo complemento experimental de Gradle y Android Studio 1.5 ).

    Android Studio y el NDK están bien integrados, de modo que solo necesitas crear un bloque ndk {} en el build.gradle de tu módulo, y establecer tus archivos de origen en el directorio (module) / src / main / jni ¡hecho!

    No más ndk-build desde la línea de comandos.

    He escrito todo sobre ello en mi blog aquí: http://www.sureshjoshi.com/mobile/android-ndk-in-android-studio-with-swig/

    Los puntos más destacados son:

    Hay dos cosas que usted necesita saber aquí. De forma predeterminada, si tiene libs externas que desea cargar en la aplicación de Android, se buscarán en el (módulo) / src / main / jniLibs de forma predeterminada. Puede cambiar esto utilizando settingSets.main.jniLibs.srcDirs en build.gradle de su módulo. Necesitará un subdirectorio con bibliotecas para cada arquitectura que esté orientando (por ejemplo, x86, brazo, mips, arm64-v8a, etc …)

    El código que desea ser compilado de forma predeterminada por la cadena de herramientas NDK se encuentra en (módulo) / src / main / jni y de forma similar a lo anterior, puede cambiarlo estableciendo sourceSets.main.jni.srcDirs en build.gradle de su módulo

    Y poner esto en build.gradle de su módulo:

     ndk { moduleName "SeePlusPlus" // Name of C++ module (ie libSeePlusPlus) cFlags "-std=c++11 -fexceptions" // Add provisions to allow C++11 functionality stl "gnustl_shared" // Which STL library to use: gnustl or stlport } 

    Ese es el proceso de compilación de su código C ++, a partir de ahí es necesario cargarlo, y crear envolturas – pero a juzgar por su pregunta, ya sabes cómo hacer todo eso, por lo que no volver a hash.

    Además, he colocado un repo Github de este ejemplo aquí: http://github.com/sureshjoshi/android-ndk-swig-example

    ACTUALIZACIÓN: 14 de junio de 2015

    Cuando aparezca Android Studio 1.3, debería haber un mejor soporte para C ++ a través del complemento JetBrains CLion. Actualmente estoy bajo la suposición de que esto permitirá el desarrollo de Java y C ++ desde Android Studio; Sin embargo creo que todavía tendremos que usar la sección de Gradle NDK como he dicho anteriormente. Además, creo que seguirá habiendo la necesidad de escribir archivos de Java <-> C ++, a menos que CLion los haga automáticamente.

    ACTUALIZACIÓN: 5 de enero de 2016

    He actualizado mi blog y Github repo (en la rama de desarrollo) para utilizar Android Studio 1.5 con el último complemento experimental Gradle (0.6.0-alpha3).

    http://www.sureshjoshi.com/mobile/android-ndk-in-android-studio-with-swig/ http://github.com/sureshjoshi/android-ndk-swig-example

    La construcción de Gradle para la sección NDK ahora se ve así:

     android.ndk { moduleName = "SeePlusPlus" // Name of C++ module (ie 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 } 

    Además, bastante impresionante, Android Studio tiene auto-completar para C ++ – Java generado envolturas utilizando la palabra clave 'nativo':

    Ejemplo de auto-completar de C ++ - Java wrapper

    Sin embargo, no es completamente color de rosa … Si usted está utilizando SWIG para envolver una biblioteca para generar automáticamente el código, y después intentar utilizar la autogeneración nativa del keyword, pondrá el código en el lugar incorrecto en su Swag _wrap .cxx … Entonces necesitas moverlo al bloque "extern C":

    C ++ - El contenedor de Java se trasladó a la ubicación correcta

    En Google IO 2015, Google anunció la integración completa de NDK en Android Studio 1.3.

    Ahora está fuera de la vista previa y está disponible para todos: https://developer.android.com/studio/projects/add-native-code.html

    Respuesta antigua: Gradle llama automáticamente a ndk-build si tiene un directorio jni en las fuentes del proyecto.

    Esto está funcionando en Android studio 0.5.9 (canary build).

    1. Descargar el NDK
    2. Agregue ANDROID_NDK_HOME a sus variables de entorno o añada ndk.dir=/path/to/ndk a su local.properties en su proyecto de Android Studio. Esto permite que Android Studio ejecute el ndk automáticamente.
    3. Descargue los últimos proyectos de ejemplo de gradle para ver un ejemplo de un proyecto ndk. (Están en la parte inferior de la página). Un buen proyecto de muestra es ndkJniLib .
    4. Copie el gradle.build de los proyectos de ejemplo NDK. Se verá algo así. Este gradle.build crea un apk diferente para cada arquitectura. Debe seleccionar la arquitectura que desea utilizando el panel de build variants . Panel de variantes de construcción

       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 } } 

    Tenga en cuenta que esto ignorará los archivos de Android.mk y Application.mk. Como solución alternativa, puede indicar gradle para desactivar la llamada de build de nomatic-build, y luego especificar manualmente el directorio de fuentes 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 } 

    Además, probablemente desee llamar a ndk-build en su script de compilación gradle explícitamente, porque acaba de inhabilitar la llamada automática.

     task ndkBuild(type: Exec) { commandLine 'ndk-build', '-C', file('src/main/jni').absolutePath } tasks.withType(JavaCompile) { compileTask -> compileTask.dependsOn ndkBuild } 

    Encontré "gradle 1.11 com.android.tools.build:gradle:0.9.+" es compatible con pre-build ndk ahora, solo puede poner el * .so en el dir src / main / jniLibs. Cuando el gradle de la construcción empaquetará el ndk al lugar correcto.

    Aquí está mi proyecto

     Proyecto:
     | --src
     | - | --main
     Java
     | - | - | --jniLibs
     | - | - | - |
     Archivos
     | --libs
     Jajaja
    

    Como dijo Xavier, puedes poner tus prebuilts en / src / main / jniLibs / si usas gradle 0.7.2+

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

    A partir de ahora (Android Studio v0.8.6) es bastante simple. Estos son los pasos para crear una aplicación de tipo "Hello world":

    1. Descargar el Android NDK y poner la carpeta raíz en algún lugar sano – en la misma ubicación que la carpeta SDK, tal vez.

    2. Agregue lo siguiente a su archivo local.properties : ndk.dir=<path-to-ndk>

    3. Agregue lo siguiente al archivo build.gradle dentro del cierre defaultConfig , justo después de la línea ndk { moduleName="hello-world" } : ndk { moduleName="hello-world" }

    4. En el directorio main del módulo de aplicaciones, cree una nueva carpeta llamada jni .

    5. En esa carpeta, cree un archivo llamado hello-world.c , que verá a continuación.

    6. Vea el ejemplo de código de Activity continuación para un ejemplo de cómo llamar a un método (o es una función?) En hello-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']) } 

    Encuentra el código fuente completo de una aplicación muy similar aquí (menos el NDK).

    Si estás en unix, la última versión (0.8) agrega ndk-build. A continuación, le indicamos cómo añadirlo:

     android.ndk { moduleName "libraw" } 

    Se espera encontrar el JNI bajo 'src / main / jni', de lo contrario se puede definir con:

     sourceSets.main { jni.srcDirs = 'path' } 

    A partir del 28 de enero de 2014 con la versión 0.8 la construcción se rompe en las ventanas, usted tiene que deshabilitar la construcción con:

     sourceSets.main { jni.srcDirs = [] //disable automatic ndk-build call (currently broken for windows) } 

    Una solución elegante se muestra en https://groups.google.com/d/msg/adt-dev/nQobKd2Gl_8/Z5yWAvCh4h4J .

    Básicamente se crea un tarro que contiene "lib / armeabi / yourlib.so" y luego incluir el tarro en la construcción.

    Una buena respuesta automatizando el empaque de los .so .so-compilados fácilmente se da en otro hilo (cerrado) . Para conseguir ese funcionamiento, tuve que cambiar la línea:

     from fileTree(dir: 'libs', include: '**/*.so') 

    dentro:

     from fileTree(dir: 'src/main/libs', include: '**/*.so') 

    Sin este cambio, los archivos .so no se encontraron, y la tarea de empaquetarlos nunca se ejecutaría.

    La respuesta de @plaisthos rompió en la última versión de gradle, pero todavía hay una manera de hacerlo. Cree un directorio native-libs en la raíz de su directorio del proyecto y copie todos sus libs en este directorio.

    Agregue las siguientes líneas a su build.gradle. Construir y ser feliz.

     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' 

    Este es el código que uso para construir usando android-ndk de gradle. Para ello, agregue la ruta del directorio gradle.properties en gradle.properties es decir. Agregue ndkdir=/home/user/android-ndk-r9d y coloque todos los archivos jni en una carpeta native en src/main/ como se puede ver en el código que aparece a continuación. Se creará jar con libs nativos que puede utilizar normalmente como en 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' 

    He utilizado el siguiente código para compilar las bibliotecas de Dropbox nativas, estoy usando 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) } 

    He utilizado ndk.dir=/usr/shareData/android-ndk-r11b // ruta de acceso de ndk

    En el archivo local.properties en android studio project. Y agregue esta línea:
    android.useDeprecatedNdk=true

    En el archivo gradle.properties en android studio project.

    Más información aquí: http://tools.android.com/tech-docs/android-ndk-preview

    Para expandir lo que Naxos dijo (gracias Naxos por enviarme en la dirección correcta!), Aprendí un poco de los ejemplos de NDK recientemente publicado y publicó una respuesta en una pregunta similar aquí.

    Cómo configurar NDK con Android Gradle plugin 0.7

    Esta publicación tiene detalles completos sobre la vinculación de bibliotecas nativas pre-construidas en su aplicación para las distintas arquitecturas, así como información sobre cómo agregar soporte NDK directamente al script build.gradle. Para la mayor parte, usted no debe necesitar hacer el trabajo alrededor de la cremallera y de la copia más.

    Estos son los pasos que utilicé para que el NDK funcionara en mi proyecto de Android Studio. He utilizado este tutorial para ayudarme a cabo https://software.intel.com/en-us/videos/using-the-ndk-with-android-studio

    Para utilizar NDK debe agregar una línea NDK a local.properties. Así que bajo su sdk.dir agregar

     ndk.dir=C\:\\MyPathToMyNDK\ndk 

    En mis aplicaciones build.gradle tengo el siguiente código

      ndk { moduleName "myLib" ldLibs "log" stl "gnustl_shared" cFlags "-std=c++11 -frtti -fexceptions -pthread" } 

    ModuleName es el nombre que desea dar a su código nativo. Creo que esto es lo que se llamará la biblioteca compartida. LdLibs me permite registrar en LogCat, stl es el stl que desea importar. Hay muchas opciones, igual que el Eclipse NDK. ( http://www.kandroid.org/ndk/docs/CPLUSPLUS-SUPPORT.html )

    CFlags son todavía una cierta cantidad de magia negra para mí. No he encontrado una buena fuente para todas las opciones y lo que me dan. Buscar alrededor de StackOverflow para cualquier cosa que usted necesita, que es donde lo encontré. Sé que el c + + 11 me permite usar el nuevo c + + 11 estándar.

    A continuación se muestra un ejemplo de cómo registro en LogCat desde el código nativo

     __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()); 

    Configurar proyecto en android studio desde eclipse: tienes que importar eclipse ndk proyecto a android studio sin exportar a gradle y funciona, tambien necesitas agregar ruta de ndk en local.properties , si muestra error luego agrega

     sourceSets.main { jniLibs.srcDir 'src/main/libs' jni.srcDirs = [] //disable automatic ndk-build callenter code here } 

    En el fichero build.gradle entonces cree la carpeta y el archivo jni usando el terminal y ejecútelo funcionará

    Ahora que Android Studio está en el canal estable, es bastante sencillo obtener las muestras de android-ndk . Estas muestras utilizan el complemento ndk experimental y son más recientes que las vinculadas desde la documentación en línea de Android NDK. Una vez que sepa que funcionan, puede estudiar los archivos build.gradle, local.properties y gradle-wrapper.properties y modificar su proyecto en consecuencia. Los siguientes son los pasos para que funcionen.

    1. Vaya a configuración, Apariencia y comportamiento, Configuración del sistema, SDK de Android, seleccione la pestaña Herramientas de SDK y compruebe la versión 1.0.0 de Android NDK en la parte inferior de la lista. Esto descargará el NDK.

    2. Señale la ubicación del NDK recién descargado. Tenga en cuenta que se colocará en el directorio sdk / ndk-bundle. Para ello, seleccione Archivo, Estructura del proyecto, Ubicación del SDK (a la izquierda) y suministre una ruta en la ubicación de Android NDK. Esto agregará una entrada ndk a local.properties similar a esto:

      Mac / Linux: ndk.dir = / Android / sdk / ndk-bundle
      Windows: ndk.dir = C: \ Android \ sdk \ ndk-bundle

    He construido y desplegado con éxito todos los proyectos en el repositorio de esta manera, excepto gles3gni, nativo-codec y constructor. Estoy usando lo siguiente:

    Android Studio 1.3 build AI-141.2117773
    Android-ndk muestras publicadas el 28 de julio de 2015 (enlace anterior)
    Herramientas de SDK 24.3.3
    NDK r10e extraído a C: \ Android \ sdk \ ndk-bundle
    Gradle 2.5
    Gradle plugin 0.2.0
    Windows 8.1 64 bit

    NDK Construye y gradle (básico)

    Generalmente construir con el NDK es tan simple como especificar correctamente una ruta ndkBuild a Android.mk o cmake la ruta a CMakeLists.txt. Recomiendo CMake sobre el Android.mk más antiguo porque el soporte de C / C ++ de Android Studio se basa en CLion y utiliza CMake como su formato de proyecto. Esto en mi experiencia ha tendido a hacer que el IDE responda mejor a proyectos más grandes. Todo lo compilado en su proyecto será construido y copiado automáticamente en el 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']) } 

    Adición de bibliotecas pre-construidas al proyecto (avanzado)

    Las bibliotecas estáticas (.a) en su compilación NDK se incluirán automáticamente, pero las bibliotecas dinámicas (.so) pre-construidas deberán colocarse en jniLibs . Esto puede ser configurado usando sourceSets , pero debe adoptar el estándar. No necesita ningún comando adicional en build.gradle cuando incluya bibliotecas pre-construidas.

    El diseño de jniLibs

    Puede encontrar más información sobre la estructura en la Guía del usuario de Android Gradle Plugin .

     |--app: |--|--build.gradle |--|--src: |--|--|--main |--|--|--|--java |--|--|--|--jni |--|--|--|--|--CMakeLists.txt |--|--|--|--jniLibs |--|--|--|--|--armeabi |--|--|--|--|--|--.so Files |--|--|--|--|--armeabi-v7a |--|--|--|--|--|--.so Files |--|--|--|--|--x86 |--|--|--|--|--|--.so Files 

    A continuación, puede validar el APK resultante que contiene los archivos .so, normalmente en build/outputs/apk/ , utilizando unzip -l myApp.apk para listar el contenido.

    Creación de bibliotecas compartidas

    Si está creando una biblioteca compartida en el NDK, no necesita hacer nada más. Estará correctamente incluido en el APK.

    Sólo build.gradle añadir estas líneas a la aplicación 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) } 

    Now.I puede cargar el éxito tan!

    1.add el archivo .so a esta ruta de acceso

     Project: 

    | –src | – | –main | – | – | –java | – | – | –jniLibs | – | – | Archivos

    2.add este código a gradle.build

     android { splits { abi { enable true reset() include 'x86', 'x86_64', 'arm64-v8a', 'armeabi-v7a', 'armeabi' universalApk false } } 

    }

    3. System.loadLibrary("yousoname");

    1. Goodluck para ti, está bien con gradle 1.2.3
    1. Si su proyecto exportado desde eclipse, agregue los siguientes códigos en el archivo gradle:

       android { sourceSets{ main{ jniLibs.srcDir['libs'] } } } 

    2.Si usted crea un proyecto en el estudio de Android:

    Cree una carpeta llamada jniLibs en src / main /, y coloque sus archivos * .so en la carpeta jniLibs.

    Y copie el código como se muestra a continuación en su archivo gradle:

     android { sourceSets{ main{ jniLibs.srcDir['jniLibs'] } } } 

    Aunque creo que SJoshi (oráculo) tiene la respuesta más completa, el proyecto SWIG es un caso especial, interesante y útil, pero no generalizado para la mayoría de los proyectos que han hecho bien con los proyectos estándar de hormigas SDK + NDK. A todos nos gustaría estar utilizando Android Studio ahora lo más probable, o queremos una más amigable para la construcción de herramientas de herramientas para móviles, que gradle teóricamente ofrece.

    He publicado mi enfoque, tomado prestado de algún lugar (encontré esto en SO, pero publicó una idea esencial para la aplicación build.gradle: https://gist.github.com/truedat101/c45ff2b69e91d5c8e9c7962d4b96e841 ). En pocas palabras, recomiendo lo siguiente:

    • No actualice su proyecto a la última versión de gradle
    • Usa com.android.tools.build:gradle:1.5.0 en tu raíz del proyecto
    • Usa com.android.application en tu proyecto de aplicación
    • Asegúrese de que gradle.properties tenga: android.useDeprecatedNdk = true (en caso de que se queje)
    • Utilice el método anterior para asegurarse de que sus horas y horas de esfuerzo para crear archivos de Android.mk no se eliminarán. Usted controla qué arco (s) de objetivo construir. Y estas instrucciones son amables para los usuarios de Windows, que en teoría podría ser capaz de construir en ventanas sin problemas especiales.

    Gradle para Android ha sido un desastre en mi opinión, tanto como me gustan los conceptos de maven prestados y la estructura opinativa de los directorios de un proyecto. Esta característica de NDK ha estado "pronto" por casi 3+ años.

    FlipAndroid es un fan de Google para Android, Todo sobre Android Phones, Android Wear, Android Dev y Aplicaciones para Android Aplicaciones.