Я очень новичок в этой поддержке gradle и Android Studio. Мне удалось преобразовать проект андроида в gradle с помощью опции экспорта.
Но я ищу некоторую документацию или отправную точку, как интегрировать сборку NDK в процесс сборки gradle.
Если возможно, мне также нужен какой-то "после" этап, который копирует двоичные файлы сборки (.so файлы) в каталог ресурсов.
Мы выпустили первую версию интеграции в виде предварительного просмотра в версии 1.3: http://tools.android.com/tech-docs/android-ndk-preview
Интеграция останется предварительной, даже после того, как 1.3 станет окончательным. Нет текущей ETA, когда она будет окончательной (по состоянию на 2015/07/10).
Дополнительная информация здесь: http://tools.android.com/tech-docs/android-ndk-preview
ОБНОВЛЕНИЕ: Android-студия с поддержкой NDK отсутствует: http://tools.android.com/tech-docs/android-ndk-preview
Для построения с помощью script ниже должно использоваться решение gradle ниже:
Я использую мою сборку script и добавлен в мой файл (Кажется, работает для 0.8+): Это похоже на решение ниже (но выглядит лучше в файле gradle):
android {
sourceSets {
main {
jniLibs.srcDirs = ['native-libs']
jni.srcDirs = [] //disable automatic ndk-build
}
}
}
Сборка, к сожалению, не сбой, если каталог отсутствует или не содержит файлов .so.
Благодаря обновлению Android Studio до 1.0 поддержка инструментальных средств NDK значительно улучшилась (примечание : прочитайте мои обновления в нижней части этого сообщения, чтобы увидеть использование нового экспериментального плагина Gradle и Android Studio 1.5).
Android Studio и NDK интегрированы достаточно хорошо, так что вам просто нужно создать блок ndk {} в модуле build.gradle и установить исходные файлы в каталог (module)/src/main/jni - и все готово!
Нет больше ndk-build из командной строки.
Я написал все об этом в своем блоге: http://www.sureshjoshi.com/mobile/android-ndk-in-android-studio-with-swig/
Основные моменты:
Здесь вам нужно знать две вещи. По умолчанию, если у вас есть внешние библиотеки, которые вы хотите загрузить в приложение для Android, их по умолчанию ищут в (module)/src/main/jniLibs. Вы можете изменить это, используя настройку sourceSets.main.jniLibs.srcDirs в своих модулях build.gradle. Вам понадобится подкаталог с библиотеками для каждой ориентированной вами архитектуры (например, x86, arm, mips, arm64-v8a и т.д.)
Код, который вы хотите скомпилировать по умолчанию с помощью инструментальной цепи NDK, будет находиться в (module)/src/main/jni и аналогично выше, вы можете изменить его, установив sourceSets.main.jni.srcDirs в своих модулях build.gradle
и поместите это в свой модуль build.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
}
Это процесс компиляции кода на С++, оттуда вам нужно загрузить его и создать обертки - но, судя по вашему вопросу, вы уже знаете, как это сделать, поэтому я не буду повторно хешировать.
Кроме того, я разместил здесь репозиторий Github: http://github.com/sureshjoshi/android-ndk-swig-example
Когда выйдет Android Studio 1.3, должна быть улучшена поддержка С++ через плагин JetBrains CLion. В настоящее время я предполагаю, что это позволит разрабатывать Java и С++ из Android Studio; однако я думаю, что нам все равно придется использовать раздел Gradle NDK, как я уже говорил выше. Кроме того, я думаю, что все еще будет необходимо писать файлы оболочки Java ↔ С++, если CLION не сделает это автоматически.
Я обновил свой блог и реплику Github (в ветке разработки), чтобы использовать Android Studio 1.5 с последним экспериментальным плагином Gradle (0.6.0-alpha3).
http://www.sureshjoshi.com/mobile/android-ndk-in-android-studio-with-swig/ http://github.com/sureshjoshi/android-ndk-swig-example
Конструкция Gradle для секции NDK теперь выглядит следующим образом:
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
}
Кроме того, довольно удивительно, Android Studio имеет автозаполнение для С++ - Java-оболочки, использующие ключевое слово 'native':
Однако, это не совсем радужно... Если вы используете SWIG, чтобы обернуть библиотеку для автоматического генерации кода, а затем попытайтесь использовать автогенерацию собственного ключевого слова, она поместит код в неправильное место в ваш файл Swig _wrap.cxx... Поэтому вам нужно переместить его в блок "extern C":
Я бы отказался, если бы не упоминал, что Android Studio 2.2 имеет по существу "родную" (без каламбуров) поддержку инструментальной привязки NDK через Gradle и CMake. Теперь, когда вы создаете новый проект, просто выберите поддержку на С++, и вам хорошо идти.
Вам все равно нужно создать собственный код уровня JNI или использовать технику SWIG, о которой я упомянул выше, но строительные леса проекта С++ в Android теперь тривиальны.
Изменения в файле CMakeLists (который размещает ваши исходные файлы на С++) будут подхвачены Android Studio, и он автоматически перекомпилирует любые связанные библиотеки.
Теперь он недоступен для просмотра и доступен всем: https://developer.android.com/studio/projects/add-native-code.html
ndk-build, если в источниках проекта есть каталог jni.Это работает на студии Android 0.5.9 (canary build).
ANDROID_NDK_HOME в переменные среды, либо добавьте ndk.dir=/path/to/ndk в ваш local.properties в вашем проекте Android Studio. Это позволяет студии Android запускать ndk автоматически.ndkJniLib.Скопируйте gradle.build из типовых проектов NDK. Это будет выглядеть примерно так. Этот gradle.build создает для каждой архитектуры другой apk. Вы должны выбрать, какую архитектуру вы хотите использовать с помощью панели 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
}
}
Обратите внимание, что это игнорирует ваши файлы Android.mk и Application.mk. В качестве обходного пути вы можете сообщить Gradle отключить atuomatic вызов ndk-build, а затем вручную указать каталог для источников 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
}
Кроме того, вы, вероятно, захотите напрямую вызвать ndk-build в свой Gradle build script, потому что вы просто отключили автоматический вызов.
task ndkBuild(type: Exec) {
commandLine 'ndk-build', '-C', file('src/main/jni').absolutePath
}
tasks.withType(JavaCompile) {
compileTask -> compileTask.dependsOn ndkBuild
}
Я нашел "gradle 1.11 com.android.tools.build:gradle:0.9.+" теперь поддерживает предварительную сборку ndk, вы можете просто поместить *.so в каталог dir src/main/jniLibs. при построении gradle будет пакет ndk в нужном месте.
вот мой проект
Project: |--src |--|--main |--|--|--java |--|--|--jniLibs |--|--|--|--armeabi |--|--|--|--|--.so files |--libs |--|--other.jar
Как сказал Ксавье, вы можете поместить свои пребульты в/src/main/jniLibs/если вы используете gradle 0.7.2 +
взято из: https://groups.google.com/d/msg/adt-dev/nQobKd2Gl_8/ctDp9viWaxoJ
На данный момент (Android Studio v0.8.6) это довольно просто. Ниже приведены шаги по созданию приложения типа "Hello world":
Загрузите Android NDK и поместите корневую папку куда-нибудь здраво - в том же месте, что и папка SDK, возможно.
Добавьте в свой local.properties файл следующее:
ndk.dir=<path-to-ndk>
Добавьте следующее в ваш файл build.gradle внутри закрытия defaultConfig сразу после строки versionName: ndk { moduleName="hello-world" }
В вашем каталоге приложений main создайте новую папку под названием jni.
В этой папке создайте файл с именем hello-world.c, который вы увидите ниже.
Ниже приведен пример кода Activity для примера того, как вызвать метод (или это функция?) в 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'])
}
Найти полный исходный код очень похожего приложения здесь (минус NDK).
Если вы используете unix, последняя версия (0.8) добавляет ndk-build. Здесь, как добавить его:
android.ndk {
moduleName "libraw"
}
Он рассчитывает найти JNI в разделе 'src/main/jni', иначе вы можете определить его с помощью
sourceSets.main {
jni.srcDirs = 'path'
}
Начиная с 28 JAN 2014 с версией 0.8 сборка разбивается на окна, вам нужно отключить сборку с помощью:
sourceSets.main {
jni.srcDirs = [] //disable automatic ndk-build call (currently broken for windows)
}
Элегантное обходное решение показано в https://groups.google.com/d/msg/adt-dev/nQobKd2Gl_8/Z5yWAvCh4h4J.
В основном вы создаете банку, которая содержит "lib/armeabi/yourlib.so", а затем включайте банку в сборку.
Хороший ответ, автоматизирующий упаковку скомпилированных .so файлов, приведен в другом (закрытом) потоке. Чтобы получить эту работу, мне пришлось изменить строку:
from fileTree(dir: 'libs', include: '**/*.so')
в
from fileTree(dir: 'src/main/libs', include: '**/*.so')
Без этого изменения файлы .so не были найдены, поэтому задача их упаковки никогда не запускалась.
Ответ от @plaisthos разбился на последнюю версию gradle, но есть еще способ сделать это.
Создайте каталог native-libs в корне каталога вашего проекта и скопируйте все наши библиотеки в этот каталог.
Добавьте следующие строки в build.gradle. Постройте и будьте счастливы.
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'
Это код, который я использую для создания с использованием android-ndk из gradle. Для этого добавьте путь каталога ndk в gradle.properties т.е. добавьте ndkdir=/home/user/android-ndk-r9d и поместите все jni файлы в папку native в src/main/, как вы можете видеть из приведенного ниже кода. Он создаст jar с собственными libs, которые вы можете использовать обычно, как в 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'
Я использовал следующий код для компиляции собственных библиотек Dropbox, я использую 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)
}
Я использовал ndk.dir=/usr/shareData/android-ndk-r11b//путь ndk
в файле local.properties в проекте студии Android. а также
добавьте эту строку: android.useDeprecatedNdk=true
в файле gradle.properties в проекте студии android.
Дополнительная информация здесь: http://tools.android.com/tech-docs/android-ndk-preview
Чтобы расширить то, что сказал Наксос (спасибо Naxos за отправку меня в правильном направлении!), я немного узнал из недавно выпущенных примеров NDK и отправил ответ в подобном вопросе здесь.
Как настроить NDK с плагином Android Gradle 0.7
В этом сообщении содержатся подробные сведения о связывании встроенных библиотек в вашем приложении для различных архитектур, а также информация о том, как добавить поддержку NDK непосредственно в build.gradle script. По большей части вам больше не нужно делать работу с zip и копией.
настроить проект в студии android из eclipse: вам нужно импортировать проект eclipse ndk в студию Android без экспорта на gradle, и он работает, также вам нужно добавить путь ndk в local.properties, если отображается ошибка, а затем добавить
sourceSets.main {
jniLibs.srcDir 'src/main/libs'
jni.srcDirs = [] //disable automatic ndk-build callenter code here
}
в файле build.gradle, затем создайте jni-папку и файл, используя терминал, и запустите его.
Вот шаги, которые я использовал, чтобы заставить NDK работать в моем проекте Android Studio. Я использовал этот учебник, чтобы помочь мне https://software.intel.com/en-us/videos/using-the-ndk-with-android-studio
Чтобы использовать NDK, вы должны добавить строку NDK в local.properties. Итак, под вашим sdk.dir добавьте
ndk.dir=C\:\\MyPathToMyNDK\ndk
В моих приложениях build.gradle у меня есть следующий код
ndk {
moduleName "myLib"
ldLibs "log"
stl "gnustl_shared"
cFlags "-std=c++11 -frtti -fexceptions -pthread"
}
moduleName - это имя, которое вы хотите дать своему родному коду. Я считаю, что это то, что будет вызываться общей библиотекой. ldLibs позволяет мне регистрироваться в LogCat, stl - это stl, который вы хотите импортировать. Есть много вариантов, таких же, как Eclipse NDK. (http://www.kandroid.org/ndk/docs/CPLUSPLUS-SUPPORT.html)
cFlags для меня все еще есть определенное количество черной магии. Я не нашел хорошего источника для всех вариантов и того, что они мне дают. Найдите вокруг StackOverflow все, что вам нужно, вот где я его нашел. Я знаю, что С++ 11 позволяет мне использовать новый стандарт С++ 11.
Вот пример того, как я записываю LogCat из собственного кода
__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());
Теперь, когда Android Studio находится в стабильном канале, довольно просто получить android-ndk samples. Эти образцы используют ndk экспериментальный плагин и новее, чем те, которые связаны с онлайн-документацией Android NDK. Как только вы знаете, что они работают, вы можете изучить файлы build.gradle, local.properties и gradle -wrapper.properties и соответственно изменить свой проект. Ниже приведены шаги, чтобы заставить их работать.
Перейдите к настройкам, внешнему виду и поведению, системным настройкам, Android SDK, выберите вкладку SDK Tools и установите Android NDK версии 1.0.0 в нижней части списка. Это загрузит NDK.
Укажите местоположение недавно загруженного NDK. Обратите внимание, что он будет помещен в каталог sdk/ndk-bundle. Сделайте это, выбрав "Файл", "Структура проекта", "Расположение SDK" (слева) и укажите путь в Android NDK. Это добавит запись ndk в local.properties, подобную этому:
Mac/Linux: ndk.dir =/Android/sdk/ndk-bundle
Windows: ndk.dir = C:\Android\sdk\ndk-bundle
Я успешно создал и развернул все проекты в репозитории таким образом, за исключением gles3gni, native-codec и builder. Я использую следующее:
Android Studio 1.3 build AI-141.2117773
Образцы android-ndk, опубликованные 28 июля 2015 г. (ссылка выше)
SDK Tools 24.3.3
NDK r10e извлечен в C:\Android\sdk\ndk-bundle
Gradle 2,5
Gradle плагин 0.2.0
Windows 8.1 64 бит
Как правило, создание с помощью NDK так же просто, как правильное указание пути ndkBuild к Android.mk или пути cmake к CMakeLists.txt. Я рекомендую CMake над старым Android.mk, потому что поддержка Android Studio C/С++ основана на CLion и использует CMake в качестве формата проекта. Это по моему опыту, как правило, делает IDE более восприимчивым к более крупным проектам. Все, скомпилированные в вашем проекте, будут автоматически созданы и скопированы в APK.
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'])
}
Статические библиотеки (.a) в вашей сборке NDK будут автоматически включены, но готовые динамические библиотеки (.so) должны быть помещены в jniLibs. Это можно настроить с помощью sourceSets, но вы должны принять стандарт. Вам не нужны дополнительные команды в build.gradle при включении готовых библиотек.
jniLibsДополнительную информацию о структуре можно найти в Android gradle Руководство пользователя плагина.
|--app: |--|--build.gradle |--|--src: |--|--|--main |--|--|--|--java |--|--|--|--jni |--|--|--|--|--CMakeLists.txt |--|--|--|--jniLibs |--|--|--|--|--armeabi |--|--|--|--|--|--.so Files |--|--|--|--|--armeabi-v7a |--|--|--|--|--|--.so Files |--|--|--|--|--x86 |--|--|--|--|--|--.so Files
Затем вы можете проверить, что полученный APK содержит ваши .so файлы, обычно под build/outputs/apk/, используя unzip -l myApp.apk для отображения содержимого.
Если вы создаете общую библиотеку в NDK, вам больше не нужно ничего делать. Он будет правильно установлен в APK.
Просто добавьте эти строки в приложение 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)
}
now.I может загрузить такой успех!
1. присоединить файл .so к этому пути
Project:
| --src | - | --main | - | - | --java | - | - | --jniLibs | - | - | - | --armeabi | - | - | - | - | -. так файлы
2. присоедините этот код к gradle.build
android {
splits {
abi {
enable true
reset()
include 'x86', 'x86_64', 'arm64-v8a', 'armeabi-v7a', 'armeabi'
universalApk false
}
}
}
3. System.loadLibrary("yousoname");
Если ваш проект экспортирован из eclipse, добавьте коды ниже в файл gradle:
android {
sourceSets{
main{
jniLibs.srcDir['libs']
}
}
}
2.Если вы создаете проект в студии Android:
создайте папку с именем jniLibs в src/main/и поместите ваши файлы *.so в папку jniLibs.
И скопируйте код, как показано ниже в файле gradle:
android {
sourceSets{
main{
jniLibs.srcDir['jniLibs']
}
}
}
Хотя я считаю, что SJoshi (oracle guy) имеет самый полный ответ, проект SWIG - это особый случай, интересный и полезный, при этом, но не обобщенный для большинства проектов, которые хорошо справились со стандартным SDK ant проекты + NDK. Мы все хотели бы использовать Android-студию сейчас, скорее всего, или хотим создать более удобную для CI конструкцию toolchain для мобильных устройств, которую теоретически предлагает gradle.
Я разместил свой подход, заимствованный где-то (я нашел это на SO, но разместил текст для приложения build.gradle: https://gist.github.com/truedat101/c45ff2b69e91d5c8e9c7962d4b96e841). Вкратце я рекомендую следующее:
Gradle для Android был бесполезным, на мой взгляд, так же, как мне нравятся концептуальные концепции maven и ущемленная структура каталогов для проекта. Эта функция NDK была "скоро" в течение почти 3 лет.