it-swarm.com.de

Android Studio, Gradle und NDK

Ich bin sehr neu in diesem ganzen Gradle und Android Studio Support. Es ist mir gelungen, mein Android-Projekt mithilfe der Exportoption in Gradle zu konvertieren.

Ich bin jedoch auf der Suche nach Dokumentation oder Ausgangspunkt, um den NDK-Build in den Gradle-Build-Prozess zu integrieren. 

Wenn möglich, brauche ich auch eine Art "after" -Stufe, in der die Build-Binaries (.so-Dateien) in das Asset-Verzeichnis kopiert werden.

148
plaisthos

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 hier: http://tools.Android.com/tech-docs/Android-ndk-preview

82
Xavier Ducrohet

UPDATE: Das Android Studio mit NDK-Unterstützung ist jetzt verfügbar: http://tools.Android.com/tech-docs/Android-ndk-preview

Für das Erstellen mit einem Skript sollte die folgende Gradle-Lösung funktionieren:

Ich verwende mein Build-Skript und fügte meiner Datei hinzu (scheint für 0.8+ zu funktionieren): Dies scheint der Lösung unten 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 .so-Dateien enthält.

42
plaisthos

Mit dem Update von Android Studio auf 1.0 wurde die NDK-Toolchain-Unterstützung immens verbessert (Anmerkung: Bitte lesen Sie meine Updates unten in diesem Beitrag, um die Verwendung mit dem neuen experimentellen Gradle-Plugin und Android Studio 1.5) zu sehen.

Android Studio und das NDK sind so gut integriert, dass Sie lediglich einen ndk {} -Baustein im Modul build.gradle Ihres Moduls erstellen und Ihre Quelldateien in das Verzeichnis (module)/src/main/jni setzen müssen erledigt! 

Kein ndk-build mehr von der Kommandozeile aus.

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

Die hervorstechenden Punkte sind:

Hier gibt es zwei Dinge, die Sie wissen müssen. Wenn Sie externe Bibliotheken haben, die Sie in die Android-Anwendung laden möchten, werden diese standardmäßig in (Modul)/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 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 müssen Sie ihn laden und Wrapper erstellen. Aber wenn Sie nach Ihrer Frage urteilen, wissen Sie bereits, wie das alles zu tun ist.

Ich habe auch ein Github-Repo dieses Beispiels hier platziert: http://github.com/sureshjoshi/Android-ndk-swig-example

UPDATE: 14. Juni 2015

Wenn Android Studio 1.3 herauskommt, sollte C++ durch 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, wir müssen immer noch den Gradle NDK-Abschnitt verwenden, wie ich oben ausgeführt habe. Ich denke auch, dass es noch notwendig sein wird, Java <-> C++ - Wrapper-Dateien zu schreiben, es sei denn, CLion führt diese automatisch aus.

UPDATE: 5. Januar 2016

Ich habe mein Blog und das Github-Repo (im Entwicklungsbereich) 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 -Beispiel

Der Gradle-Build für den NDK-Abschnitt sieht jetzt so 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
}

Ganz offensichtlich hat Android Studio für C++ - Java generierte Wrapper mit dem Schlüsselwort 'native' automatisch vervollständigt:

 Example of auto-complete of C++-Java wrapper

Es ist jedoch nicht völlig rosig ... Wenn Sie SWIG verwenden, um eine Bibliothek zum automatischen Generieren von Code einzubinden, und dann versuchen, das native Schlüsselwort für die automatische Generierung zu verwenden, wird der Code an die falsche Stelle in Ihrem Swig-Wrapper eingefügt .cxx-Datei ... Sie müssen sie also in den Block "extern C" verschieben:

 C++-Java wrapper moved to correct location

UPDATE: 15. Oktober 2017

Ich wäre nicht zufrieden, wenn ich nicht erwähnte, dass Android Studio 2.2 im Wesentlichen "native" (kein Wortspiel) für die NDK-Toolchain über Gradle und CMake unterstützt. Wenn Sie jetzt ein neues Projekt erstellen, wählen Sie einfach die C++ - Unterstützung aus und Sie können loslegen. 

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-Projekten ist jetzt trivial.

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

39
SJoshi

In Google IO 2015 gab Google die vollständige NDK-Integration in Android Studio 1.3 bekannt.

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 ndk-build auf, wenn sich in Ihren Projektquellen ein jni-Verzeichnis befindet.

Dies funktioniert auf Android Studio 0.5.9 (Canary Build).

  1. Laden Sie den NDK herunter
  2. Fügen Sie entweder Android_NDK_HOME zu Ihren Umgebungsvariablen hinzu oder fügen Sie ndk.dir=/path/to/ndk zu Ihrem local.properties in Ihrem Android Studio-Projekt hinzu. Dadurch kann Android Studio die ndk automatisch ausführen.
  3. Laden Sie die latest Gradle-Beispielprojekte herunter , um ein Beispiel für ein ndk-Projekt zu sehen. (Sie sind am unteren Rand der Seite). Ein gutes Beispielprojekt ist ndkJniLib.
  4. Kopieren Sie den gradle.build aus den NDK-Beispielprojekten. Es wird ungefähr so ​​aussehen. Dieser gradle.build erstellt für jede Architektur eine andere apk. Sie müssen auswählen, welche Architektur Sie im Bereich build variants verwenden möchten .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
        }
    
    }
    

Beachten Sie, dass dies Ihre Android.mk- und Application.mk-Dateien ignoriert. Um dieses Problem zu umgehen, können Sie Gradle anweisen, den Aufruf atuomatic ndk-build zu deaktivieren, und dann das Verzeichnis für die ndk-Quellen manuell angeben.

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 in Ihrem Gradle-Build-Skript den Befehl ndk-build explizit aufrufen, da Sie den automatischen Aufruf gerade deaktiviert haben.

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

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

Ich fand "gradle 1.11 com.Android.tools.build:gradle:0.9.+" unterstützt jetzt Pre-Build ndk. Sie können das * .so einfach in das Verzeichnis src/main/jniLibs . Setzen, wenn gradle wird erstellt packen Sie die ndk an die richtige Stelle.

hier ist mein projekt

 Projekt: 
 | --Src 
 | - | --main 
 | - | - | --Java 
 | - | - | --jniLibs 
 | - | - | - | --armeabi 
 | - | - | - | - | -. so Dateien 
 | --libs 
 | - | - -andere.jar 
23
Eric Woo

Wie Xavier sagte, können Sie Ihre Vorabversionen 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

18
Naxos

Ab sofort (Android Studio v0.8.6) ist es recht einfach. So erstellen Sie eine App "Hallo Welt":

  1. Laden Sie das Android-NDK herunter und legen Sie den Stammordner an einem sicheren Ort ab - am selben Ort wie der SDK-Ordner.

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

  3. Fügen Sie Ihrer build.gradle -Datei innerhalb der defaultConfig-Schließung direkt nach der versionName-Zeile Folgendes hinzu: ndk { moduleName="hello-world" }

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

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

  6. Im folgenden Beispiel Activity-Code finden Sie ein 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'])
}

Hier finden Sie den vollständigen Quellcode einer sehr ähnlichen App (ohne NDK).

15
Matt Logan

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

Android.ndk {
    moduleName "libraw"
}

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

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

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

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

Eine elegante Problemumgehung wird in https://groups.google.com/d/msg/adt-dev/nQobKd2Gl_8/Z5yWAvCh4h4J angezeigt.

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

7
aleb

Die Antwort von @plaisthos brach in der neuesten Gradle-Version ein, aber es gibt noch eine Möglichkeit, dies zu tun ..__ Erstellen Sie ein native-libs-Verzeichnis im Stammverzeichnis Ihres Projektverzeichnisses und kopieren Sie alle unsere Bibliotheken in dieses Verzeichnis.

Fügen Sie Ihrem build.gradle die folgenden Zeilen hinzu. Baue und sei glücklich.

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'
4
Leandros

Eine gute Antwort zum Automatisieren des Packens von fertig zusammengestellten .so- 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 .so-Dateien nicht gefunden, und die Aufgabe zum Packen der Dateien würde daher niemals ausgeführt.

4
HYS

Dies ist der Code, den ich zum Erstellen mit Android-ndk von Gradle verwende. Für diesen add ndk Verzeichnispfad in gradle.properties dh. Fügen Sie ndkdir=/home/user/Android-ndk-r9d hinzu und legen Sie alle JNI-Dateien in einem Ordner native in src/main/ ab. Es wird Jar mit nativen Bibliotheken erstellt, die Sie normalerweise wie in System.loadLibrary("libraryname"); verwenden können.

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'
3
sujithvm

Ich habe den folgenden Code verwendet, um native Dropbox-Bibliotheken zu kompilieren. 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)
}
3
Sam

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

in der Datei _/local.properties
im Android Studio-Projekt. und füge diese Zeile hinzu: 
Android.useDeprecatedNdk=true 

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

Weitere Informationen hier: http://tools.Android.com/tech-docs/Android-ndk-preview

2

NDK Builds und Gradle (Grundkenntnisse)

Im Allgemeinen ist das Erstellen mit dem NDK so einfach, dass ein ndkBuild-Pfad zu Android.mk oder ein cmake-Pfad zu CMakeLists.txt richtig angegeben wird. Ich empfehle CMake gegenüber dem älteren Android.mk, da die Unterstützung für C/C++ von Android Studio auf CLion basiert und CMake als Projektformat verwendet wird. Nach meiner Erfahrung hat dies dazu geführt, dass die IDE auf größere Projekte ansprechender 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'])
}

Vorgefertigte Bibliotheken zum Projekt hinzufügen (erweitert)

Statische Bibliotheken (.a) in Ihrem NDK-Build werden automatisch einbezogen, dynamische dynamische Bibliotheken (.so) müssen jedoch in jniLibs platziert werden. Dies kann mit sourceSets konfiguriert werden, aber Sie sollten den Standard übernehmen. Sie benötigen KEINE zusätzlichen Befehle in build.gradle, wenn 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, dass das resultierende APK Ihre .so-Dateien enthält, normalerweise unter build/outputs/apk/. Verwenden Sie unzip -l myApp.apk, um 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.

Jetzt, da sich Android Studio im stabilen Kanal befindet, ist es ziemlich unkompliziert, die Android-ndk-Beispiele zum Laufen zu bringen. Diese Beispiele verwenden das experimentelle Plugin ndk und sind neuer als diejenigen, auf die in der Android NDK-Online-Dokumentation verwiesen wird. Sobald Sie wissen, dass sie funktionieren, können Sie die Dateien build.gradle, local.properties und gradle-wrapper.properties studieren und Ihr Projekt entsprechend anpassen. Im Folgenden werden die Schritte beschrieben, damit sie funktionieren.

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

  2. Zeigen Sie auf den Ort 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 an. Dadurch wird local.properties ein ähnlicher ndk-Eintrag hinzugefügt: 

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

Ich habe auf diese Weise alle Projekte im Repository erfolgreich erstellt und implementiert, mit Ausnahme von gles3gni, nativem Codec und Builder. Ich verwende 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 wurde nach C:\Android\sdk\ndk-bundle extrahiert
Gradle 2.5
Gradle Plugin 0.2.0
Windows 8.1 64-Bit 

1
Nate

projekt in Android Studio von Eclipse 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 dann füge hinzu 

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

in der Datei build.gradle erstellen Sie dann den Ordner und die Datei jni unter Verwendung des Terminals und führen Sie die Ausführung aus

1

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

Wie konfiguriert man NDK mit Android Gradle Plugin 0.7

In diesem Beitrag finden Sie alle Details zum Verknüpfen von vorgefertigten nativen Bibliotheken in Ihre App für die verschiedenen Architekturen sowie Informationen zum direkten Hinzufügen von NDK-Unterstützung zum build.gradle-Skript. In den meisten Fällen müssen Sie die Arbeit mit Zip nicht mehr durchführen und kopieren.

1
reactive-core

Hier sind die Schritte, die ich verwendet habe, um den NDK in meinem Android Studio-Projekt zum Laufen zu bringen ... __ Ich habe dieses Tutorial verwendet, um mir zu helfen https://software.intel.com/de-de/videos/ using-the-ndk-with-Android-studio

Um NDK verwenden zu können, müssen Sie der Datei 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"
        }

moduleName ist der Name, den Sie Ihrem eigenen Code geben möchten. Ich glaube, das wird die gemeinsam genutzte Bibliothek heißen. ldLibs ermöglicht es mir, mich bei LogCat anzumelden. stl ist die zu importierende stl. 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 schwarze Magie. Ich habe keine gute Quelle für alle Optionen und das, was sie mir geben, gefunden. 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 ein Beispiel, wie ich mich vom nativen Code aus 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());
1
GR Envoy

jetzt.Ich kann den so Erfolg laden!

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

Project:

| --src | - | --main | - | - | --Java | - | - | --jniLibs | - | - - | --armeabi | - | - | - | - | - .so 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");

  1. viel glück für dich, es ist ok mit gradle 1.2.3
0
xiaoyuan hu

Fügen Sie diese Zeilen einfach zur App build.gradle hinzu.

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)
}
0
sagus_helgy
  1. Wenn Ihr Projekt aus Eclipse exportiert wurde, fügen Sie die unten stehenden Codes in der Abstufungsdatei hinzu:

    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 kopiere den Code wie unten in deiner Gradle-Datei:

Android {
    sourceSets{  
       main{  
         jniLibs.srcDir['jniLibs']  
      }  
    }
}
0
Yachao

Obwohl ich glaube, dass SJoshi (Oracle-Typ) die umfassendste Antwort hat, ist das SWIG-Projekt ein interessanter und nützlicher Sonderfall, aber nicht für die Mehrzahl der Projekte verallgemeinert, die mit den auf SDK basierenden Standardprojekten + erfolgreich waren NDK. Wir alle möchten das Android-Studio jetzt höchstwahrscheinlich verwenden oder eine CI-freundlichere Build-Toolchain für Mobilgeräte, die Gradle theoretisch anbietet.

Ich habe meinen Ansatz irgendwo entlehnt (ich habe dies auf SO gefunden, aber eine Gist für die App build.gradle: https://Gistubith.com/truedat101/c45ff2b69e91d5c8e9c7962d4b96e841 ). Kurz gesagt, empfehle ich Folgendes:

  • Aktualisieren Sie Ihr Projekt nicht auf den neuesten Gradle-Build
  • Verwenden Sie com.Android.tools.build:gradle: 1.5.0 in Ihrem Project-Stamm
  • Verwenden Sie com.Android.application in Ihrem App-Projekt
  • Stellen Sie sicher, dass gradle.properties Folgendes hat: Android.useDeprecatedNdk = true (falls es sich beschwert)
  • Verwenden Sie den oben beschriebenen Ansatz, um sicherzustellen, dass Ihre stundenlangen Anstrengungen beim Erstellen von Android.mk-Dateien nicht weggeworfen werden. Sie bestimmen, welche Bögen auf Arches angelegt werden sollen. Und diese Anweisungen sind freundlich zu Windows-Benutzern, die theoretisch auf Fenster ohne spezielle Probleme aufbauen können.

Gradle für Android war meiner Meinung nach ein Chaos, so wie ich die ausgeliehenen Maven-Konzepte und die meinungsbildende Struktur der Verzeichnisse für ein Projekt mag. Dieses NDK-Feature ist seit fast 3 Jahren "in Kürze". 

0
truedat101