Ich bin sehr neu in diesem ganzen Gradle und Android Studio Support. Ich habe es geschafft, mein Android-Projekt mithilfe der Exportoption in Gradle zu konvertieren.

Ich suche jedoch nach einer Dokumentation oder einem Ausgangspunkt für die Integration des NDK-Builds in den Gradle-Build-Prozess.

Wenn möglich, benötige ich auch eine Art "After" -Stufe, in der die Build-Binärdateien (.so-Dateien) in das Asset-Verzeichnis kopiert werden.

Wir haben eine erste Version der Integration als Vorschau in 1.3 veröffentlicht: http://tools.android.com/tech-docs/android-ndk-preview

Die Integration bleibt eine Vorschau, auch wenn 1.3 endgültig ist. Keine aktuelle ETA, wann es endgültig sein wird (Stand 10.07.2015).

Weitere Informationen finden Sie hier: http://tools.android.com/tech-docs/android-ndk-preview

UPDATE: Das Android Studio mit NDK-Unterstützung ist ab sofort erhältlich: http://tools.android.com/tech-docs/android-ndk-preview

Zum Erstellen mit einem Skript sollte die folgende Gradle-Lösung funktionieren:

Ich verwende mein Build-Skript und füge es meiner Datei hinzu (scheint zu funktionieren 0.8+): Dies scheint der folgenden Lösung zu entsprechen (sieht aber in der Gradle-Datei besser aus):

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

Der Build schlägt leider nicht fehl, wenn das Verzeichnis nicht vorhanden ist oder keine .soDateien enthält .

Mit dem Update von Android Studio auf 1.0 wurde die Unterstützung der NDK-Toolchain immens verbessert ( Hinweis: Bitte lesen Sie meine Updates am Ende dieses Beitrags, um die Verwendung mit dem neuen experimentellen Gradle-Plugin und Android Studio 1.5 zu sehen ).

Android Studio und das NDK sind gut genug integriert, sodass Sie nur einen ndk {} -Block im build.gradle Ihres Moduls erstellen und Ihre Quelldateien in das Verzeichnis (module) / src / main / jni legen müssen - und schon sind Sie da getan!

Kein ndk-Build mehr über die Kommandozeile.

Ich habe alles darüber in meinem Blog-Beitrag hier geschrieben: http://www.sureshjoshi.com/mobile/android-ndk-in-android-studio-with-swig/

Die wichtigsten Punkte sind:

Hier müssen Sie zwei Dinge wissen. Wenn Sie externe Bibliotheken haben, die in die Android-Anwendung geladen werden sollen, werden diese standardmäßig in der Datei (module) / src / main / jniLibs gesucht. Sie können dies ändern, indem Sie sourceSets.main.jniLibs.srcDirs im build.gradle Ihres Moduls festlegen. Sie benötigen ein Unterverzeichnis mit Bibliotheken für jede Architektur, auf die Sie abzielen (z. B. x86, arm, mips, arm64-v8a usw.).

Der Code, den Sie standardmäßig von der NDK-Toolchain kompilieren möchten, befindet sich in (module) / src / main / jni. Ähnlich wie oben können Sie ihn ändern, indem Sie sourceSets.main.jni.srcDirs im build.gradle Ihres Moduls festlegen

und fügen Sie dies in das build.gradle Ihres Moduls ein:

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
}

Das ist der Prozess des Kompilierens Ihres C ++ - Codes. Von dort aus müssen Sie ihn laden und Wrapper erstellen. Nach Ihrer Frage zu urteilen, wissen Sie jedoch bereits, wie das alles funktioniert, damit ich nicht erneut hashe.

Außerdem habe ich hier ein Github-Repo dieses Beispiels platziert: http://github.com/sureshjoshi/android-ndk-swig-example

UPDATE: 14. Juni 2015

Wenn Android Studio 1.3 herauskommt, sollte C ++ über das JetBrains CLion-Plugin besser unterstützt werden. Ich gehe derzeit davon aus, dass dies die Entwicklung von Java und C ++ in Android Studio ermöglicht. Ich denke jedoch, dass wir weiterhin den Gradle NDK-Abschnitt verwenden müssen, wie ich oben angegeben habe. Ich denke außerdem, dass Java <-> C ++ - Wrapper-Dateien weiterhin geschrieben werden müssen, es sei denn, CLion führt diese automatisch aus.

UPDATE: 5. Januar 2016

Ich habe mein Blog und mein Github-Repo (im Entwicklungszweig) aktualisiert, um Android Studio 1.5 mit dem neuesten experimentellen Gradle-Plugin (0.6.0-alpha3) zu verwenden.

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

Der Gradle-Build für den NDK-Abschnitt sieht nun folgendermaßen aus:

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
}

Außerdem hat Android Studio eine automatische Vervollständigung für C ++ - Java-generierte Wrapper mit dem Schlüsselwort 'native':

Es ist jedoch nicht ganz rosig ... Wenn Sie SWIG verwenden, um eine Bibliothek zum automatischen Generieren von Code zu verpacken, und dann versuchen, das native Schlüsselwort zur automatischen Generierung zu verwenden, wird der Code an der falschen Stelle in Ihrem Swig _wrap abgelegt .cxx-Datei ... Sie müssen sie also in den Block "extern C" verschieben:

UPDATE: 15. Oktober 2017

Ich würde mich sehr freuen, wenn ich nicht erwähnen würde, dass Android Studio 2.2 ab im Wesentlichen "native" (kein Wortspiel) Unterstützung für die NDK-Toolchain über Gradle und CMake bietet. Wenn Sie jetzt ein neues Projekt erstellen, wählen Sie einfach C ++ - Unterstützung und los geht's.

Sie müssen immer noch Ihren eigenen JNI-Layer-Code generieren oder die oben erwähnte SWIG-Technik verwenden, aber das Gerüst eines C ++ in Android-Projekts ist jetzt trivial.

Änderungen in der CMakeLists-Datei (in der Sie Ihre C ++ - Quelldateien ablegen) werden von Android Studio übernommen und alle zugehörigen Bibliotheken automatisch neu kompiliert.

In Google IO 2015 kündigte Google die vollständige NDK-Integration in Android Studio 1.3 an.

Es ist jetzt nicht mehr in der Vorschau und für alle verfügbar: https://developer.android.com/studio/projects/add-native-code.html

Alte Antwort: Gradle ruft automatisch an, ndk-buildwenn Sie ein jniVerzeichnis in Ihren Projektquellen haben.

Dies funktioniert unter Android Studio 0.5.9 (Canary Build).

1. Laden Sie das NDK herunter

2. Fügen Sie entweder ANDROID_NDK_HOMEzu Ihren Umgebungsvariablen oder ndk.dir=/path/to/ndkzu Ihren local.propertiesin Ihrem Android Studio-Projekt hinzu. Dadurch kann Android Studio das ndk automatisch ausführen.

3. Laden Sie die neuesten Gradle-Beispielprojekte herunter , um ein Beispiel für ein ndk-Projekt zu sehen. (Sie sind am Ende der Seite). Ein gutes Beispielprojekt ist ndkJniLib.

4. Kopieren Sie die gradle.buildaus den NDK-Beispielprojekten. Es wird ungefähr so ​​aussehen. Dies gradle.builderstellt eine andere apk für jede Architektur. Sie müssen im Bereich auswählen, welche Architektur Sie möchten 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
       }
   
   }

Beachten Sie, dass dadurch Ihre Android.mk- und Application.mk-Dateien ignoriert werden. Um dieses Problem zu umgehen, können Sie gradle anweisen, den atuomatischen ndk-Build-Aufruf zu deaktivieren und dann das Verzeichnis für ndk-Quellen manuell anzugeben.

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
}

Außerdem möchten Sie wahrscheinlich ndk-build in Ihrem Gradle-Build-Skript explizit aufrufen, da Sie gerade den automatischen Aufruf deaktiviert haben.

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

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

Ich fand, dass "gradle 1.11 com.android.tools.build:gradle:0.9.+" jetzt Pre-Build ndk unterstützt. Sie können einfach die * .so in das Verzeichnis src / main / jniLibs einfügen. Beim Bau von Gradle wird der ndk an der richtigen Stelle verpackt.

Hier ist mein Projekt

Projekt:
| --src
| - | --main
| - | - | --java
| - | - | --jniLibs
| - | - | - | --armeabi
| - | - | - | - | -. also Dateien
| --libs
| - | --other.jar

Wie Xavier sagte, können Sie Ihre Prebuilts in / src / main / jniLibs / ablegen, wenn Sie Gradle 0.7.2+ verwenden

entnommen aus: https://groups.google.com/d/msg/adt-dev/nQobKd2Gl_8/ctDp9viWaxoJ

Ab sofort (Android Studio v0.8.6) ist es ganz einfach. Hier sind die Schritte zum Erstellen einer App vom Typ "Hallo Welt":

1. Laden Sie das Android NDK herunter und legen Sie den Stammordner an einem vernünftigen Ort ab - möglicherweise am selben Speicherort wie der SDK-Ordner.

2. Fügen Sie Ihrer local.propertiesDatei Folgendes hinzu : ndk.dir=<path-to-ndk>

3. Fügen Sie Ihrer build.gradle-Datei innerhalb des defaultConfigVerschlusses direkt nach der versionNameZeile Folgendes hinzu:ndk { moduleName="hello-world" }

4. mainErstellen Sie im Verzeichnis Ihres App-Moduls einen neuen Ordner mit dem Namen jni.

5. Erstellen hello-world.cSie in diesem Ordner eine Datei mit dem Namen , die Sie unten sehen werden.

6. Im folgenden Beispielcode finden Sie Activityein Beispiel für den Aufruf einer Methode (oder ist es eine Funktion?) In 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'])
}

Den vollständigen Quellcode einer sehr ähnlichen App finden Sie hier (abzüglich des NDK).

Wenn Sie unter Unix arbeiten, fügt die neueste Version (0.8) ndk-build hinzu. So fügen Sie es hinzu:

android.ndk {
    moduleName "libraw"
}

Es wird erwartet, dass die JNI unter 'src / main / jni' gefunden wird, andernfalls können Sie sie definieren mit:

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

Ab dem 28. Januar 2014 mit Version 0.8 ist der Build unter Windows fehlerhaft. Sie müssen den Build deaktivieren mit:

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

Eine elegante Problemumgehung finden Sie unter https://groups.google.com/d/msg/adt-dev/nQobKd2Gl_8/Z5yWAvCh4h4J .

Grundsätzlich erstellen Sie ein Glas, das "lib / armeabi / yourlib.so" enthält, und fügen das Glas dann in den Build ein.

Eine gute Antwort zur Automatisierung des .soPackens von leicht kompilierbaren Dateien finden Sie in einem anderen (geschlossenen) Thread . Damit das funktioniert, musste ich die Zeile ändern:

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

in:

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

Ohne diese Änderung wurden die .soDateien nicht gefunden und die Aufgabe zum Packen würde daher niemals ausgeführt.

Die Antwort von @plaisthos wurde in der neuesten Gradle-Version veröffentlicht, aber es gibt immer noch eine Möglichkeit, dies zu tun. Erstellen Sie ein native-libsVerzeichnis im Stammverzeichnis Ihres Projektverzeichnisses und kopieren Sie alle Ihre Bibliotheken in dieses Verzeichnis.

Fügen Sie Ihrem build.gradle die folgenden Zeilen hinzu. Bauen und glücklich sein.

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'

Dies ist der Code, den ich benutze, um mit android-ndk von gradle zu erstellen. Fügen Sie dazu den ndk-Verzeichnispfad in gradle.propertiesdh hinzu. ndkdir=/home/user/android-ndk-r9dFügen Sie alle jni-Dateien hinzu und legen Sie sie in einem Ordner nativeab, src/main/wie Sie anhand des unten angegebenen Codes sehen können. Es wird ein Jar mit nativen Bibliotheken erstellt, die Sie normalerweise wie in verwenden könnenSystem.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'

Ich habe den folgenden Code zum Kompilieren nativer Dropbox-Bibliotheken verwendet. Ich verwende 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)
}

Ich habe ndk.dir=/usr/shareData/android-ndk-r11b // Pfad von ndk

in der Datei local.properties im Android Studio-Projekt verwendet. und fügen Sie diese Zeile hinzu:
android.useDeprecatedNdk=true

in der Datei gradle.properties im Android Studio-Projekt.

Weitere Informationen finden Sie hier: http://tools.android.com/tech-docs/android-ndk-preview

Um das zu erweitern, was Naxos gesagt hat (Danke, Naxos, dass Sie mich in die richtige Richtung geschickt haben!), Habe ich aus den kürzlich veröffentlichten NDK-Beispielen einiges gelernt und hier eine Antwort in einer ähnlichen Frage gepostet.

So konfigurieren Sie NDK mit dem Android Gradle Plugin 0.7

Dieser Beitrag enthält ausführliche Informationen zum Verknüpfen vorgefertigter nativer Bibliotheken mit Ihrer App für die verschiedenen Architekturen sowie Informationen zum direkten Hinzufügen von NDK-Unterstützung zum Skript build.gradle. Zum größten Teil sollten Sie die Arbeit um Zip und Kopieren nicht mehr erledigen müssen.

Hier sind die Schritte, mit denen ich das NDK in meinem Android Studio-Projekt zum Laufen gebracht habe. Ich habe dieses Tutorial verwendet, um https://software.intel.com/en-us/videos/using-the-ndk-with-android-studio zu unterstützen

Um NDK verwenden zu können, müssen Sie local.properties eine NDK-Zeile hinzufügen. Also unter deiner sdk.dir hinzufügen

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

In meinen Apps build.gradle habe ich den folgenden Code

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

Modulname ist der Name, den Sie Ihrem nativen Code geben möchten. Ich glaube, so wird die gemeinsam genutzte Bibliothek heißen. Mit ldLibs kann ich mich bei LogCat anmelden. STL ist die STL, die Sie importieren möchten. Es gibt viele Optionen, genau wie beim Eclipse NDK. ( http://www.kandroid.org/ndk/docs/CPLUSPLUS-SUPPORT.html )

cFlags sind für mich immer noch eine gewisse Menge schwarzer Magie. Ich habe keine gute Quelle für alle Optionen gefunden und was sie mir geben. Suchen Sie in StackOverflow nach allem, was Sie brauchen. Dort habe ich es gefunden. Ich weiß, dass ich mit c ++ 11 den neuen c ++ 11-Standard verwenden kann.

Hier ist ein Beispiel, wie ich mich vom nativen Code bei LogCat anmelde

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

Projekt in Android Studio von Eclipse aus konfigurieren : Sie müssen das Eclipse-ndk-Projekt in Android Studio importieren, ohne es in Gradle zu exportieren, und es funktioniert. Außerdem müssen Sie den Pfad von ndk in local.properties hinzufügen . Wenn ein Fehler angezeigt wird , fügen Sie ihn hinzu

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

in build.gradle Datei dann erstellen jni Ordner- und Datei mit Terminal und führen Sie es funktioniert

Jetzt, da sich Android Studio im stabilen Kanal befindet, ist es ziemlich einfach, die Android-Ndk-Beispiele zum Laufen zu bringen. Diese Beispiele verwenden das experimentelle Plugin ndk und sind neuer als die in der Online-Dokumentation zu Android NDK verlinkten. Sobald Sie wissen, dass sie funktionieren, können Sie die Dateien build.gradle, local.properties und gradle-wrapper.properties studieren und Ihr Projekt entsprechend ändern. Im Folgenden finden Sie die Schritte, um sie zum Laufen zu bringen.

1. Gehen Sie zu Einstellungen, Aussehen und Verhalten, Systemeinstellungen, Android SDK, wählen Sie die Registerkarte SDK-Tools und überprüfen Sie Android NDK Version 1.0.0 am Ende der Liste. Dadurch wird das NDK heruntergeladen.

2. Zeigen Sie auf den Speicherort des neu heruntergeladenen NDK. Beachten Sie, dass es im Verzeichnis sdk / ndk-bundle abgelegt wird. Wählen Sie dazu Datei, Projektstruktur, SDK-Speicherort (links) und geben Sie einen Pfad unter Android NDK-Speicherort ein. Dadurch wird ein ndk-Eintrag zu local.properties hinzugefügt, der dem folgenden ähnelt:

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

Ich habe alle Projekte im Repository auf diese Weise erfolgreich erstellt und bereitgestellt, mit Ausnahme von gles3gni, nativem Codec und Builder. Ich benutze folgendes:

Android Studio 1.3 Build AI-141.2117773
Android-Ndk-Beispiele veröffentlicht am 28. Juli 2015 (Link oben)
SDK-Tools 24.3.3
NDK r10e extrahiert in C: \ Android \ sdk \ ndk-Bundle
Gradle 2.5
Gradle-Plugin 0.2.0
Windows 8.1 64-Bit

NDK Builds und Gradle (Basic)

Im Allgemeinen ist das Erstellen mit dem NDK so einfach wie das korrekte Angeben eines ndkBuild-Pfads zu Android.mk oder eines cmake-Pfads zu CMakeLists.txt. Ich empfehle CMake gegenüber dem älteren Android.mk, da die C / C ++ - Unterstützung von Android Studio auf CLion basiert und CMake als Projektformat verwendet. Dies hat meiner Erfahrung nach dazu geführt, dass die IDE bei größeren Projekten schneller reagiert. Alles, was in Ihrem Projekt kompiliert wurde, wird automatisch erstellt und in die APK kopiert.

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

Hinzufügen vorgefertigter Bibliotheken zum Projekt (erweitert)

Statische Bibliotheken (.a) in Ihrem NDK-Build werden automatisch aufgenommen, vorgefertigte dynamische Bibliotheken (.so) müssen jedoch abgelegt werden jniLibs. Dies kann mit konfiguriert werden sourceSets, aber Sie sollten den Standard übernehmen. Sie benötigen keine zusätzlichen Befehle, build.gradlewenn Sie vorgefertigte Bibliotheken einschließen.

Das Layout von jniLibs

Weitere Informationen zur Struktur finden Sie im Android Gradle Plugin Benutzerhandbuch .

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

Sie können dann überprüfen, ob die resultierende APK Ihre .so-Dateien enthält, normalerweise unter build/outputs/apk/, unzip -l myApp.apkum den Inhalt aufzulisten .

Gemeinsame Bibliotheken erstellen

Wenn Sie eine gemeinsam genutzte Bibliothek im NDK erstellen, müssen Sie nichts weiter tun. Es wird korrekt in der APK gebündelt.

Fügen Sie einfach diese Zeilen zur App hinzu 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)
}

Ich kann den so Erfolg laden!

1. Fügen Sie die .so-Datei zu diesem Pfad hinzu

Project:

| --src | - | --main | - | - | --java | - | - | --jniLibs | - | - | - | --armeabi | - | - | - | - | -. also Dateien

2. Fügen Sie diesen Code zu gradle.build hinzu

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

}}

3.System.loadLibrary("yousoname");

4. viel glück für dich, es ist ok mit gradle 1.2.3

1. Wenn Ihr Projekt aus Eclipse exportiert wurde, fügen Sie die folgenden Codes in die Gradle-Datei ein:

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

2.Wenn Sie ein Projekt in Android Studio erstellen:

Erstellen Sie einen Ordner mit dem Namen jniLibs in src / main / ， und legen Sie Ihre * .so-Dateien im Ordner jniLibs ab.

Und kopieren Sie den Code wie folgt in Ihre Gradle-Datei:

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

Während ich glaube, dass SJoshi (Orakel-Typ) die vollständigste Antwort hat, ist das SWIG-Projekt ein Sonderfall, interessant und nützlich, aber nicht verallgemeinert für die Mehrheit der Projekte, die mit den Standard-SDK-Ameisen-basierten Projekten + gut abgeschnitten haben NDK. Wir alle möchten jetzt höchstwahrscheinlich Android Studio verwenden oder möchten eine CI-freundlichere Build-Toolchain für Mobilgeräte, die gradle theoretisch bietet.

Ich habe meinen Ansatz veröffentlicht, von irgendwoher ausgeliehen (ich habe ihn auf SO gefunden, aber einen Kern für die App build.gradle veröffentlicht: https://gist.github.com/truedat101/c45ff2b69e91d5c8e9c7962d4b96e841 ). Kurz gesagt, ich empfehle Folgendes:

• Aktualisieren Sie Ihr Projekt nicht auf den neuesten Gradle-Build
• Verwenden Sie com.android.tools.build:gradle:1.5.0 in Ihrem Projektstamm
• Verwenden Sie com.android.application in Ihrem App-Projekt
• Stellen Sie sicher, dass gradle.properties Folgendes enthält: android.useDeprecatedNdk = true (falls es sich beschwert)
• Verwenden Sie den oben beschriebenen Ansatz, um sicherzustellen, dass Ihre stundenlangen Bemühungen beim Erstellen von Android.mk-Dateien nicht weggeworfen werden. Sie steuern, welche Zielbögen erstellt werden sollen. Und diese Anweisungen sind freundlich zu Windows-Benutzern, die theoretisch in der Lage sein sollten, ohne besondere Probleme auf Windows aufzubauen.

Gradle für Android war meiner Meinung nach ein Chaos, genauso wie ich die geliehenen Maven-Konzepte und die meinungsgebundene Struktur von Verzeichnissen für ein Projekt mag. Diese NDK-Funktion ist seit fast 3 Jahren "in Kürze" verfügbar.