web-dev-qa-db-fra.com

Compiler et utiliser des binaires exécutables dépendants d'ABI dans Android avec Android Studio 2.2 et CMake)

Je teste le nouveau bâtiment Android Studio C/C++ via CMake via gradle stable ( http://tools.Android.com/tech-docs/external-c- builds ).

Dans mon application, un appareil déjà enraciné doit utiliser un binaire dépendant d'ABI que je compile à l'intérieur Android Studio.

Lorsque j'essaie de compiler une bibliothèque standard avec

add_library(mylib SHARED mylib.c)

il est automatiquement compilé et copié dans le dossier lib/[ABI] de l'APK (par exemple /lib/armeabi/mylib.so) mais si je compile un binaire exécutable avec:

add_executable(mybinary mybinary.cpp)

les binaires sont générés correctement dans le dossier de construction:

app/build/intermediates/cmake/debug/lib/armeabi/mybinary
app/build/intermediates/cmake/debug/lib/x86_64/mybinary 
...

mais ils ne semblent pas être copiés n'importe où dans l'apk.

Quelle est la bonne façon de répondre à ce besoin? Une tâche graduelle est-elle la voie à suivre?

build.gradle:

apply plugin: 'com.Android.application'

Android {
    compileSdkVersion 24
    buildToolsVersion "24.0.1"
    defaultConfig {
        applicationId "com.my.app"
        minSdkVersion 10
        targetSdkVersion 24
        versionCode 1
        versionName "1.0"
        testInstrumentationRunner "Android.support.test.runner.AndroidJUnitRunner"
        externalNativeBuild {
            cmake {
                cppFlags ""
            }
        }
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-Android.txt'), 'proguard-rules.pro'
        }
    }
    externalNativeBuild{
        cmake{
            path "CMakeLists.txt"
        }
    }

    defaultConfig {
        externalNativeBuild {
            cmake {
                targets "
                arguments "-DANDROID_TOOLCHAIN=clang", "-DANDROID_PLATFORM=Android-21"
                cFlags "-DTEST_C_FLAG1", "-DTEST_C_FLAG2"
                cppFlags "-DTEST_CPP_FLAG2", "-DTEST_CPP_FLAG2"
                abiFilters 'x86', 'x86_64', 'armeabi', 'armeabi-v7a'
            }
        }
    }
}

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    androidTestCompile('com.Android.support.test.espresso:espresso-core:2.2.2', {
        exclude group: 'com.Android.support', module: 'support-annotations'
    })
    testCompile 'junit:junit:4.12'
    compile 'com.Android.support:appcompat-v7:24.1.1'
    compile 'com.Android.support:design:24.1.1'
    compile 'com.Android.support:recyclerview-v7:24.1.1'
    compile 'eu.chainfire:libsuperuser:1.0.0.201607041850'
}

CMakeLists.txt

cmake_minimum_required(VERSION 3.4.1)

set(CMAKE_VERBOSE_MAKEFILE on)

add_executable(mybinary ${CMAKE_CURRENT_SOURCE_DIR}/mybinary.cpp)
target_link_libraries( mybinary libcustom)
target_include_directories (mybinary PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})

mybinary.cpp

#include <stdlib.h>
#include <string>
#include <iostream>

using namespace std;

int main(int argc, char *argv[]) {

    string hello = "Hello from C++";
    cout << "Message from native code: " << hello << "\n";

    return EXIT_SUCCESS;
}

Comment l'application doit interagir avec mybinary:

import eu.chainfire.libsuperuser.Shell;
...
Shell.SU.run("/path/to/mybinary");
androidandroid-studiogradleandroid-ndkcmake
16
ADD

Ok, j'ai trouvé une solution qui semble assez confortable, mais il existe probablement des moyens plus appropriés;

CMakeLists.txt est par défaut placé dans myAppProject/app, j'ai donc ajouté cette ligne à CMakeLists.txt:

set(EXECUTABLE_OUTPUT_PATH      "${CMAKE_CURRENT_SOURCE_DIR}/src/main/assets/${Android_ABI}")

application complète/CMakeLists.txt:

cmake_minimum_required(VERSION 3.4.1)

set(CMAKE_VERBOSE_MAKEFILE on)

# set binary output folder to Android assets folder
set(EXECUTABLE_OUTPUT_PATH      "${CMAKE_CURRENT_SOURCE_DIR}/src/main/assets/${Android_ABI}")

add_subdirectory (src/main/cpp/mylib)
add_subdirectory (src/main/cpp/mybinary)

application complète/src/main/cpp/mybinary/CMakeLists.txt:

add_executable(mybinary ${CMAKE_CURRENT_SOURCE_DIR}/mybinary.cpp)
# mybinary, in this example, has mylib as dependency
target_link_libraries( mybinary mylib)
target_include_directories (mybinary PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})

application complète/src/main/cpp/mylib/CMakeLists.txt:

add_library( # Sets the name of the library.
             mylib

             # Sets the library as a shared library.
             SHARED

             # Provides a relative path to your source file(s).
             # Associated headers in the same location as their source
             # file are automatically included.
             ${CMAKE_CURRENT_SOURCE_DIR}/mylib.cpp )

target_include_directories (mylib PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})

Ce faisant, tout binaire exécutable est compilé directement dans le dossier d'actifs, à l'intérieur d'un sous-dossier dont le nom est l'ABI cible, par exemple:

assets/armeabi/mybinary
assets/x86_64/mybinary
...

Afin d'utiliser le bon binaire dans l'application, le bon binaire doit être sélectionné:

String abi;
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Lollipop) {
    abi = Build.SUPPORTED_ABIS[0];
} else {
    //noinspection deprecation
    abi = Build.CPU_ABI;
}
String folder;
if (abi.contains("armeabi-v7a")) {
    folder = "armeabi-v7a";
} else if (abi.contains("x86_64")) {
    folder = "x86_64";
} else if (abi.contains("x86")) {
    folder = "x86";
} else if (abi.contains("armeabi")) {
    folder = "armeabi";
}
...
AssetManager assetManager = getAssets();
InputStream in = assetManager.open(folder+"/" + "mybinary");

Ensuite, le binaire doit être copié à partir du dossier des ressources avec les autorisations d'exécution correctes:

OutputStream out = context.openFileOutput("mybinary", MODE_PRIVATE);
long size = 0;
int nRead;
while ((nRead = in.read(buff)) != -1) {
    out.write(buff, 0, nRead);
    size += nRead;
}
out.flush();
Log.d(TAG, "Copy success: " +  " + size + " bytes");
File execFile = new File(context.getFilesDir()+"/mybinary");
execFile.setExecutable(true);

C'est tout!

MISE À JOUR: fichier gradle.build:

apply plugin: 'com.Android.application'

Android {
    compileSdkVersion 25
    buildToolsVersion "25"
    defaultConfig {
        applicationId "com.myapp.example"
        minSdkVersion 10
        targetSdkVersion 25
        versionCode 1
        versionName "1.0"
        testInstrumentationRunner "Android.support.test.runner.AndroidJUnitRunner"
        externalNativeBuild {
            cmake {
                cppFlags ""
            }
        }
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-Android.txt'), 'proguard-rules.pro'
        }
    }
    externalNativeBuild {
        cmake {
            path "CMakeLists.txt"
        }
    }

    defaultConfig {
        externalNativeBuild {
            cmake {
                targets "mylib", "mybinary"
                arguments "-DANDROID_TOOLCHAIN=clang"
                cFlags "-DTEST_C_FLAG1", "-DTEST_C_FLAG2"
                cppFlags "-DTEST_CPP_FLAG2", "-DTEST_CPP_FLAG2"
                abiFilters 'armeabi', 'armeabi-v7a', 'x86', 'x86_64'
            }
        }
    }
}

dependencies {
    compile fileTree(include: ['*.jar'], dir: 'libs')
    androidTestCompile('com.Android.support.test.espresso:espresso-core:2.2.2', {
        exclude group: 'com.Android.support', module: 'support-annotations'
    })
    testCompile 'junit:junit:4.12'
    compile 'com.Android.support:appcompat-v7:25.0.0'
    compile 'com.Android.support:design:25.0.0'
    compile 'com.Android.support:recyclerview-v7:25.0.0'
    compile 'com.Android.support:cardview-v7:25.0.0'
    compile 'eu.chainfire:libsuperuser:1.0.0.201607041850'
}
18
ADD

  1. Faites sortir les fichiers exécutables à l'endroit où le plug-in Android Gradle attend les bibliothèques:

    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}")

  2. Tromper le plugin en pensant que votre exécutable est un objet partagé:

    add_executable(i_am_an_executable.so main.c)

  3. Vérifiez l'APK:

    $ 7z l build/sorties/apk/app-debug.apk lib/[2:08:56] 
 Date Heure Attr Taille Nom compressé 
 ----------- -------- ----- ------------ ------------ ------------- ----------- 
 ..... 9684 4889 lib/armeabi/i_am_an_executable.so 
 ..... 6048 1710 lib/arm64-v8a/i_am_an_executable. donc 
 ..... 9688 4692 lib/armeabi-v7a/i_am_an_executable.so 
 ..... 5484 1715 lib/x86/i_am_an_executable.so 
 .... . 6160 1694 lib/x86_64/i_am_an_executable.so

  4. Accédez et exécutez votre exécutable; il est situé dans context.getApplicationInfo().nativeLibraryDir.

L'inconvénient est que vous ne pouvez pas définir Android:extractNativeLibs à false - Je ne connais aucun moyen d'accéder à lib/ dans un APK depuis l'application.

3
angelsl