web-dev-qa-db-fra.com

Comment ajouter JNI (code natif C / C ++) au projet Android Studio Android existant)

Comme le titre l'indique - comment ajouter du code natif au projet Android Studio Android, sans interrompre le projet actuel, y compris les paramètres de gradle et de proguard?

androidjava-native-interface
15
Vladimir

Suivez ces étapes à partir de votre projet existant:

1. Modifiez build.gradle (application Module) pour ressembler à ceci (beaucoup de changements!):

    apply plugin: 'com.Android.model.application'

    model {
        Android.signingConfigs {
            create ("myConfig") {
                keyAlias '--your-key-alias--'
                keyPassword '--key-password--'
                storeFile file('--/path/to/keystore.jks--')
                storePassword '--store-password--'
            }
        }
        Android {
            compileSdkVersion 25
            buildToolsVersion '25.0.2'

            defaultConfig {
                applicationId "--your.app.name--"
                minSdkVersion.apiLevel 19
                targetSdkVersion.apiLevel 25
                versionCode 1
                versionName "1.0"
            }
            buildTypes {
                release {
                    minifyEnabled true
                    proguardFiles.add(file('proguard-Android-optimize.txt'))
                    proguardFiles.add(file('proguard-rules.pro'))
                    signingConfig = $("Android.signingConfigs.myConfig")
                }
            }
            ndk {
                moduleName "--c-file--"
                ldLibs.addAll(["Android", "log"])
            }

        }
        Android.dexOptions {
            javaMaxHeapSize "2048m"
        }
    }

    dependencies {
        compile fileTree(dir: 'libs', include: ['*.jar'])
        testCompile 'junit:junit:4.12'
        compile 'com.Android.support:appcompat-v7:25.3.1'
    }

Vous pouvez copier/coller le code ci-dessus et modifier au moins les valeurs avec "--value--" pour correspondre à la vôtre.

2. Modifiez build.gradle (Project)

où il dit quelque chose comme ça:

dependencies {
    classpath 'com.Android.tools.build:gradle:2.3.3'
}

pour ça:

dependencies {
    classpath 'com.Android.tools.build:gradle-experimental:0.9.3'
}

Le nombre dans mon exemple 0.9.3 est la dernière version de gradle-experimental à être trouvée ici . Modifiez éventuellement votre version de gradle dans gradle-wrapper.properties à la version recommandée par Android Studio si vous ne l'avez pas déjà fait).

3. Déplacez votre fichier de paramètres proguard

proguard-Android-optimize.txt à app/proguard-Android-optimize.txt

4. Ajoutez l'appel depuis Java

comme ça

static {
    System.loadLibrary("--c-file--");
}
private native byte my_jni(Context context, byte[] mByte, int i);

en fonction de vos besoins. L'exemple ci-dessus charge le fichier c (écrivez-le sans l'extension) - le même déclaré dans le fichier gradle, et appelle la fonction my_jni, en passant le contexte de l'application, un tableau d'octets et un int, en attendant que les fonctions retournent un octet .

5. Créez la fonction dans JNI:

Maintenant, le nom de votre fonction est surligné en rouge - autorisez Android Studio à le créer Create function ... en cliquant sur la lampe rouge sur la ligne. Cela crée la fonction dans votre fichier c et y change le focus.

Terminé

Lectures complémentaires ici .

Conseils:

  • Prenez soin de free tout ce que vous malloc, ReleaseByteArrayElements pour chaque GetByteArrayElements et ainsi de suite

  • Prenez soin de renvoyer correctement certaines valeurs dangereuses de C vers Java, comme les tableaux et les chaînes

6
Vladimir

Depuis Android Studio 3.1, son possible moyen simple:

1. Créez le dossier cpp dans app\src\main.

2. Créez le fichier <YOUR_FILE_NAME>.cpp Dans le chemin app\src\main\cpp (Par exemple, native-lib.cpp)

3. Ajoutez le fichier CMakeLists.txt Au dossier app.

Dans ce nom de fichier de la bibliothèque, le chemin du fichier .cpp Et certains autres paramètres doivent être définis, par exemple (depuis un nouveau projet de studio Android vide avec prise en charge C++):

# For more information about using CMake with Android Studio, read the
# documentation: https://d.Android.com/studio/projects/add-native-code.html

# Sets the minimum version of CMake required to build the native library.

cmake_minimum_required(VERSION 3.4.1)

# Creates and names a library, sets it as either STATIC
# or SHARED, and provides the relative paths to its source code.
# You can define multiple libraries, and CMake builds them for you.
# Gradle automatically packages shared libraries with your APK.

add_library( # Sets the name of the library.
             native-lib

             # Sets the library as a shared library.
             SHARED

             # Provides a relative path to your source file(s).
             src/main/cpp/native-lib.cpp )
                          ^^^^^^^^^^^^^^
                          YOUR_CPP_FILE_NAME

# Searches for a specified prebuilt library and stores the path as a
# variable. Because CMake includes system libraries in the search path by
# default, you only need to specify the name of the public NDK library
# you want to add. CMake verifies that the library exists before
# completing its build.

find_library( # Sets the name of the path variable.
              log-lib

              # Specifies the name of the NDK library that
              # you want CMake to locate.
              log )

# Specifies libraries CMake should link to your target library. You
# can link multiple libraries, such as libraries you define in this
# build script, prebuilt third-party libraries, or system libraries.

target_link_libraries( # Specifies the target library.
                       native-lib

                       # Links the target library to the log library
                       # included in the NDK.
                       ${log-lib} )

4. Ajouter à build.gradle (module d'application) externalNativeBuild tag avec référence à CMakeLists.txt Dans la section Android: 

Android {
    compileSdkVersion 26
    defaultConfig {
        ...
    }
    buildTypes {
        ...
    }
    externalNativeBuild {               <--- these lines should be added
        cmake {                         <--- these lines should be added
            path "CMakeLists.txt"       <--- these lines should be added
        }                               <--- these lines should be added
    }                                   <--- these lines should be added
}

5. Ajouter à build.gradle (application Module) externalNativeBuild tag avec cmake tag dans defaultConfig section: 

...
defaultConfig {
    applicationId "<YOUR_APP_ID>"
    minSdkVersion 26
    targetSdkVersion 26
    versionCode 1
    versionName "1.0"
    testInstrumentationRunner "Android.support.test.runner.AndroidJUnitRunner"


    externalNativeBuild {   <--- these lines should be added
        cmake {             <--- these lines should be added
            cppFlags ""     <--- these lines should be added
        }                   <--- these lines should be added
    }                       <--- these lines should be added
}
...

(exemple de fichier "de base" build.gradle également disponible dans un nouveau projet Studio Android vide avec prise en charge C++)

6. Projet Resync avec des fichiers Gradle

En cliquant sur Sync Project Sync Project button on Toolbar dans la barre d'outils. NB! Dans Android Studio 3.3, l'icône est Android Studio 3.3 Sync Project button on Toolbar .

Jetez également un œil à Tutoriel officiel .

PS. Si les fichiers n'apparaissent pas dans le dossier cpp:

essayez File/Invalidate Caches & Restart comme Thinh V mentionné dans son commentaire.

25
Andrii Omelchenko