Aktualizacja: Android Studio z obsługą NDK jest już dostępny: http://tools.android.com/tech-docs/android-ndk-preview

W przypadku budowania ze skryptem poniższe rozwiązanie gradle powinno działać:

Używam mojego skryptu budowania i dodałem go do mojego pliku( wygląda na to, że działa dla 0.8+): wydaje się to być równoważne z poniższym rozwiązaniem (ale wygląda ładniej w pliku gradle):

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

Budowanie niestety nie kończy się niepowodzeniem, jeśli katalog nie jest obecny lub nie zawiera .so pliki.

Wraz z aktualizacją Android Studio do 1.0, obsługa NDK toolchain znacznie się poprawiła (Uwaga: proszę przeczytać moje aktualizacje na dole tego postu, aby zobaczyć wykorzystanie z nową wtyczką eksperymentalną Gradle i Android Studio 1.5).

Android Studio i NDK są na tyle dobrze zintegrowane, że wystarczy utworzyć blok NDK{} w kompilacji twojego modułu.gradle i ustaw swoje pliki źródłowe w katalogu (module)/src / main / jni - i gotowe!

Koniec z ndk-build z linii poleceń.

Pisałam o tym w moim blogu TUTAJ: http://www.sureshjoshi.com/mobile/android-ndk-in-android-studio-with-swig/

Najważniejsze punkty to:

Są dwie rzeczy, które musisz wiedzieć. Domyślnie, jeśli masz zewnętrzne biblioteki, które chcesz załadować do aplikacji na Androida, są one domyślnie szukane w (module)/src/main/jniLibs. Możesz to zmienić, ustawiając zestawy źródeł.main.jniLibs.srcDirs w Twoim Budowa modułu.gradle. X86, arm, mips, arm64-v8a, etc...)

Kod, który chcesz skompilować domyślnie przez łańcuch narzędzi NDK, będzie umieszczony w (module) / src / main / jni i podobnie jak powyżej, możesz go zmienić, ustawiając zestawy źródeł.main.jni.srcDirs w budowie twojego modułu.gradle

I włóż to do swojego modułu."gradle": {]}

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
}

To proces kompilacji twojego C++ kod, stamtąd trzeba go załadować i utworzyć wrappery - ale sądząc po twoim pytaniu, już wiesz jak to wszystko zrobić, więc nie będę ponownie hashował.

Również umieściłem repo Github tego przykładu tutaj: http://github.com/sureshjoshi/android-ndk-swig-example

Aktualizacja: 14 czerwca 2015

Gdy Pojawi Się Android Studio 1.3, powinno być lepsze wsparcie dla C++ poprzez wtyczkę JetBrains CLion. Obecnie jestem przy założeniu, że pozwoli to Javie i C++ development z poziomu Android Studio; jednak myślę, że nadal będziemy musieli użyć sekcji Gradle NDK, jak już wspomniałem powyżej. Dodatkowo myślę, że nadal będzie potrzeba pisania plików JavaC++ wrapper, chyba że CLion zrobi to automatycznie.

Aktualizacja: 5 stycznia 2016

Zaktualizowałem mój blog i Github repo (w gałęzi develop), aby używać Android Studio 1.5 z najnowszą eksperymentalną Wtyczką Gradle (0.6.0-alfa3).

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

Gradle build dla sekcji NDK wygląda teraz tak:

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
}

Ponadto, całkiem nieziemsko, Android Studio ma auto-complete dla owijarek C++-Java generowanych za pomocą słowa kluczowego 'native':

Byłbym niedbały, gdybym nie wspomniał, że Android Studio 2.2 dalej ma zasadniczo 'natywne' (bez Kalambury) wsparcie dla NDK toolchain poprzez Gradle i CMake. Teraz, gdy tworzysz nowy projekt, po prostu wybierz C++ support i możesz iść.

Nadal będziesz musiał wygenerować własny kod warstwy JNI lub użyć techniki SWIG, o której wspomniałem powyżej, ale rusztowanie projektu C++ w Androidzie jest teraz trywialne.

Zmiany w pliku CMakeLists (gdzie umieszczasz swoje pliki źródłowe C++) zostaną odebrane przez Android Studio i automatycznie skompiluje wszystkie powiązane biblioteki.

W Google IO 2015 Google ogłosiło pełną integrację NDK z Android Studio 1.3.

Jest już niedostępny i Dostępny dla wszystkich: https://developer.android.com/studio/projects/add-native-code.html

Stara odpowiedź: Gradle automatycznie wywołuje ndk-build Jeśli masz katalog jni w swoich źródłach projektu.

To działa na Android studio 0.5.9 (canary build).

1. Pobierz NDK
2. albo dodać ANDROID_NDK_HOME do zmienne środowiskowe lub dodać ndk.dir=/path/to/ndk do local.properties w projekcie Android Studio. Dzięki temu Android studio może automatycznie uruchamiać ndk.
3. Pobierz najnowsze przykładowe projekty gradle aby zobaczyć przykładowy projekt ndk. (Są na dole strony). Dobrym przykładowym projektem jest ndkJniLib.

4. Skopiuj gradle.build z przykładowych projektów NDK. To będzie wyglądało mniej więcej tak. To gradle.build tworzy inny apk dla każdej architektury. Musisz wybrać który Architektura, którą chcesz użyć w okienku build variants.

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

Zauważ, że to zignoruje Twoje Android.mk oraz Application.mk pliki. Jako obejście, możesz powiedzieć gradle, aby wyłączył atuomatyczne wywołanie NDK-build, a następnie ręcznie określić katalog źródeł 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
}

Ponadto prawdopodobnie będziesz chciał wywołać NDK-build w skrypcie gradle build jawnie, ponieważ właśnie wyłączyłeś automatyczne połączenie.

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

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

Znalazłem " gradle 1.11 com.android.narzędzia.Budowa: gradle: 0.9.+ "obsługuje pre-build NDK teraz, Można po prostu umieścić*. so w katalogu src / main / jniLibs. podczas budowania gradle zapakuje ndk we właściwe miejsce.

Oto mój projekt

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

Jak powiedział Xavier, możesz umieścić swoje prebuilty w /src/main/ jniLibs / jeśli używasz gradle 0.7.2 +

Pochodzi z: https://groups.google.com/d/msg/adt-dev/nQobKd2Gl_8/ctDp9viWaxoJ

Od teraz (Android Studio v0.8.6) jest to dość proste. Oto kroki, aby utworzyć aplikację typu "Hello world":

1. Pobierz Android NDK i umieść folder główny w rozsądnym miejscu - w tym samym miejscu, co folder SDK, być może.

2. Dodaj następujący plik local.properties: ndk.dir=<path-to-ndk>

3. Dodaj następujące elementy do swojej kompilacji.plik gradle wewnątrz defaultConfig zamknięcia, zaraz po linii versionName : ndk { moduleName="hello-world" }

4. W aplikacji katalog main modułu, utwórz nowy folder o nazwie jni.

5. W tym folderze Utwórz plik o nazwie hello-world.c, który zobaczysz poniżej.

6. Zobacz przykład kodu Activity poniżej, aby zobaczyć przykład jak wywołać metodę(lub czy jest to funkcja?) w 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'])
}

Tutaj znajdziesz Pełny kod źródłowy bardzo podobnej aplikacji (minus NDK).

Jeśli używasz Uniksa, najnowsza Wersja (0.8) dodaje ndk-build. Oto jak go dodać:

android.ndk {
    moduleName "libraw"
}

Oczekuje, że znajdzie JNI pod 'src / main / jni', w przeciwnym razie można go zdefiniować za pomocą:

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

Od 28 stycznia 2014 w wersji 0.8 build jest uszkodzony w systemie windows, musisz wyłączyć build za pomocą:

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

Eleganckie obejście zostało pokazane w https://groups.google.com/d/msg/adt-dev/nQobKd2Gl_8/Z5yWAvCh4h4J .

Zasadniczo tworzysz jar, który zawiera "lib / armeabi / yourlib.so", a następnie dołączasz jar do kompilacji.

Dobra odpowiedź automatyzująca pakowanie łatwo skompilowanych .so - plików jest podana w innym (zamkniętym) wątku . Aby to zadziałało, musiałem zmienić linię:

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

Do:

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

Bez tej zmiany pliki .so nie zostały znalezione, a zadanie ich spakowania nigdy nie byłoby uruchomione.

Odpowiedź od @ plaisthos pękła w najnowszej wersji gradle, ale wciąż jest na to sposób. Utwórz katalog native-libs w katalogu głównym Twojego projektu i skopiuj wszystkie nasze biblioteki y do tego katalogu.

Dodaj następujące linie do swojej kompilacji.gradle. Buduj i bądź szczęśliwy.

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'

To jest kod, którego używam do budowania za pomocą Androida-NDK z gradle. W tym celu dodaj ścieżkę katalogu NDK w gradle.properties ie . dodaj ndkdir=/home/user/android-ndk-r9d i umieść wszystkie pliki jni w folderze native w src/main/ Jak widać z kodu zamieszczonego poniżej. Tworzy jar z natywnymi bibliotekami, których możesz używać normalnie jak w 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'

Użyłem poniższego kodu do kompilacji natywnych bibliotek dropbox, używam 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)
}

Użyłem ndk.dir=/usr/shareData/android-ndk-r11b / / ścieżka NDK

in local.właściwości pliku w projekcie android studio. oraz dodaj ten wiersz :
android.useDeprecatedNdk=true

w gradle.właściwości pliku w projekcie android studio.

Więcej informacji tutaj: http://tools.android.com/tech-docs/android-ndk-preview

Aby rozwinąć to, co powiedział Naxos (dzięki Naxos za wysłanie mnie w dobrym kierunku!), Nauczyłem się sporo z niedawno opublikowanych przykładów NDK i zamieściłem tutaj odpowiedź na podobne pytanie.

Jak skonfigurować NDK z Androidem Gradle plugin 0.7

Ten post zawiera pełne informacje na temat łączenia wstępnie wbudowanych bibliotek natywnych do aplikacji dla różnych architektur, a także informacje o tym, jak dodać obsługę NDK bezpośrednio do kompilacji.Gradle script. Dla najbardziej część, nie powinieneś już wykonywać pracy wokół zip i kopiowania.

Oto kroki, których użyłem, aby uruchomić NDK w moim projekcie Android Studio. Użyłem tego samouczka, aby mi pomóc https://software.intel.com/en-us/videos/using-the-ndk-with-android-studio

Aby używać NDK musisz dodać linię NDK do local.właściwości. Więc pod twoim sdk.dir add

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

In my apps build.gradle mam następujący kod

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

Nazwa ModuleName to nazwa, którą chcesz nadać swojemu kodowi macierzystemu. Wierzę, że to jest to, co wspólne Biblioteka zostanie wywołana. ldLibs pozwala mi zalogować się do LogCat, stl jest stl, które chcesz zaimportować. Istnieje wiele opcji, tak samo jak Eclipse NDK. ( http://www.kandroid.org/ndk/docs/CPLUSPLUS-SUPPORT.html )

Oto przykład logowania do LogCat z kodu natywnego

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

Konfiguracja projektu w android studio z eclipse: musisz zaimportować projekt eclipse NDK do android studio bez eksportowania do gradle i działa , musisz również dodać ścieżkę ndk w lokalnym.properties ,if shows error then add

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

In build.gradle Plik następnie utwórz JNI folder i plik używając terminala i uruchom go będzie działać

Teraz, gdy Android Studio jest w stabilnym kanale, bardzo łatwo jest uruchomić Android-NDK samples. Te próbki używają NDK experimental plugin i są nowsze niż te powiązane z dokumentacją Online Androida NDK. Kiedy już wiesz, że działają, możesz przestudiować budowę.gradle, lokalne.właściwości i gradle-wrapper.pliki właściwości i odpowiednio zmodyfikować swój projekt. Poniżej znajdują się kroki, aby je uruchomić.

1. Przejdź do Ustawienia, Wygląd i zachowanie, Ustawienia systemowe, Android SDK, wybierz kartę Narzędzia SDK i sprawdź Android NDK w wersji 1.0.0 na dole listy. To ściągnie NDK.

2. Wskaż lokalizację nowo pobranego NDK. Należy pamiętać, że zostanie on umieszczony w katalogu sdk / NDK-bundle. Zrób to, wybierając Plik, strukturę projektu, lokalizację SDK (po lewej) i dostarczając ścieżkę pod lokalizacją Android NDK. Spowoduje to dodanie wpisu NDK do local.właściwości podobne do to:

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

Udało mi się zbudować i wdrożyć wszystkie projekty w repozytorium w ten sposób, z wyjątkiem gles3gni, native-codec i builder. Używam:

Android Studio 1.3 build AI-141.2117773
android-próbki NDK opublikowane 28 lipca 2015 (link powyżej)
SDK Tools 24.3.3
NDK r10e C:\Android\sdk\ndk-bundle
Gradle 2.5
Gradle plugin 0.2.0
Windows 8.1 64 bit

NDK buduje i gradle (basic)

Ogólnie budowanie z NDK jest tak proste, jak poprawne określenie ścieżki ndkBuild do Android.mk lub cmake ścieżka do CMakeLists.txt. Polecam CMake nad starszymi Android.mk ponieważ wsparcie C/C++ Android Studio opiera się na CLion i używa CMake jako formatu projektu. Z mojego doświadczenia wynika, że IDE jest bardziej elastyczne w większych projektach. Wszystko skompilowane w Twoim projekcie zostanie wbudowane i skopiowane do APK automatycznie.

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'])
}

Dodawanie gotowych bibliotek do projektu (zaawansowane)

Biblioteki statyczne (.a) w Twoim NDK build zostanie automatycznie dołączony, ale prebuilt dynamic libraries (. so) będzie musiał być umieszczony w jniLibs. Można to skonfigurować za pomocą sourceSets, ale należy przyjąć standard. Nie potrzebujesz żadnych dodatkowych poleceń w build.gradle, gdy dołączasz wstępnie wbudowane biblioteki.

Układ jniLibs

Więcej informacji o strukturze można znaleźć w Android Gradle Plugin User Guide .

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

Możesz następnie zweryfikować wynikowy plik APK zawierający Twoje pliki. so, zazwyczaj pod build/outputs/apk/, używając unzip -l myApp.apk do listy zawartości.

Budowanie bibliotek współdzielonych

Jeśli budujesz bibliotekę współdzieloną w NDK, nie musisz robić nic więcej. Zostanie on prawidłowo dołączony do pliku APK.

Po prostu dodaj tę linię do aplikacji 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)
}

Teraz.Mogę załadować tak sukces!

1.Dodaj plik. so do tej ścieżki

Project:

/ -- src / -- / -- główna |--|-- / -- java |--|-- / -- jniLibs / -- / -- / -- armeabi |--|--|--|--|--.so files

2.dodaj ten kod do 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 for you, it is ok with gradle 1.2.3

1. Jeśli twój projekt wyeksportowany z eclipse, dodaj poniższe kody do pliku gradle：

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

2.Jeśli tworzysz projekt w Android studio:

Utwórz folder o nazwie jniLibs w src / main / ，i umieść swoje pliki*. so w folderze jniLibs.

I skopiuj kod jak poniżej w pliku gradle ：

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

Chociaż uważam, że sjoshi (oracle guy) ma najbardziej kompletną odpowiedź, projekt SWIG jest szczególnym przypadkiem, interesującym i użytecznym, ale nie uogólnionym dla większości projektów, które dobrze sobie poradziły ze standardowymi projektami SDK ant + NDK. Wszyscy chcielibyśmy używać Android studio teraz najprawdopodobniej, lub chcą bardziej przyjazny Ci build toolchain dla urządzeń mobilnych, które Gradle teoretycznie oferuje.

Zamieściłem swoje podejście, zapożyczone skądś (znalazłem to na SO, ale opublikował gist dla kompilacji aplikacji.gradle: https://gist.github.com/truedat101/c45ff2b69e91d5c8e9c7962d4b96e841 ). W skrócie, polecam:

• nie Aktualizuj swojego projektu do najnowszej wersji gradle build
• Użyj com.android.narzędzia.tworzenie: gradle: 1.5.0 w korzeniu projektu
• Użyj com.android.aplikacja w projekcie aplikacji
Upewnij się, że gradle.właściwości posiada: android.useDeprecatedNdk = true (w przypadku narzekania)
• użyj powyższego podejście, aby zapewnić, że Twoje godziny i godziny wysiłku tworzenia Android.mk pliki nie zostaną wyrzucone. Możesz kontrolować, które cele arch(s) zbudować. A te instrukcje są miłe dla użytkowników systemu Windows, którzy teoretycznie powinni być w stanie budować na systemie windows bez specjalnych problemów.

Gradle dla Androida był bałagan moim zdaniem, podobnie jak lubię koncepcje maven zapożyczone i opinion struktura katalogów dla projektu. Ta funkcja NDK jest "coming soon" od prawie 3 + lat.