- Как начать работу с Native Development Kit от Android
- Предпосылки
- 1. Зачем писать собственный код?
- 2. Создание нового проекта
- 3. Создание собственной библиотеки
- 4. Использование нативной библиотеки
- Заключение
- Фоновый звук в Android с MediaSessionCompat
- Сделайте снимки с помощью своего приложения для Android
- Введение в Android NDK
- Что такое Android NDK?
- Для чего используют NDK?
- Что такое JNI?
- Преимущества JNI
- Как устроен JNI
- Локальные и глобальные ссылки
- Обработка ошибок
- Примитивные типы JNI
- Ссылочные типы JNI
- Модифицированный UTF-8
- Функции JNI
- Пример использования функций JNI
- Потоки
- Первые шаги
- Android.mk
- Application.mk
- NDK-BUILDS
- Как собрать проект?
- Вызов нативных методов из Java кода
Как начать работу с Native Development Kit от Android
С запуском Android Studio 2.2 разработка приложений для Android, содержащих код на C ++, стала проще, чем когда-либо. В этом уроке я покажу вам, как использовать набор Native Development Kit для Android, который обычно называют NDK, для создания собственной библиотеки C ++, функции которой доступны для классов Java.
Предпосылки
Чтобы иметь возможность следовать этому руководству, вам понадобится следующее:
1. Зачем писать собственный код?
Как правило, вы должны разработать приложение для Android, используя только Java. Добавление кода на C ++ значительно увеличивает его сложность и снижает его переносимость. Тем не менее, вот несколько причин, по которым вы все равно хотите это сделать:
- Чтобы максимизировать производительность: вы можете повысить производительность приложения для Android, хотя и незначительно, путем внедрения части бизнес-логики на процессоре на C ++.
- Для использования высокопроизводительных API-интерфейсов: реализация спецификаций API, таких как Vulkan Graphics и OpenSL ES, является частью NDK. Поэтому разработчики Android-игр, как правило, используют NDK.
- Использовать популярные библиотеки C / C ++: существует множество библиотек C и C ++, которые не имеют эквивалентов Java. Если вы хотите работать с ними в своем приложении для Android, использование NDK — это ваше решение.
- Повторное использование кода: до тех пор, пока код, написанный на C ++, не содержит зависимостей от конкретной платформы, он может использоваться как в приложениях Android, так и в iOS, как правило, с минимальными изменениями. Если вы разрабатываете большое приложение и собираетесь поддерживать как платформы iOS, так и Android, использование C ++ может повысить вашу производительность.
2. Создание нового проекта
В Android Studio 2.2 или выше мастер создания проектов позволяет быстро создавать новые проекты, поддерживающие код на C ++.
Начните с запуска Android Studio и нажмите кнопку Start a new Android Studio project на экране приветствия. На следующем экране дайте вашему приложению осмысленное имя и проверьте поле Include C ++ Support.
На экране создания активности мастера выберите параметр Add No Activity. На последнем экране мастера убедитесь, что для значения поля C ++ Standard установлено значение Toolchain Default и нажмите кнопку Finish.
Android NDK и инструменты, от которых он зависит, по умолчанию не установлены. Поэтому, как только проект будет сгенерирован, вы увидите ошибку, которая выглядит так:
Чтобы исправить ошибку, откройте Tools > Android > SDK Manager и перейдите на вкладку SDK Tools.
В списке доступных инструментов разработчика выберите CMake и NDK и нажмите кнопку Apply.
После завершения установки перезапустите Android Studio.
3. Создание собственной библиотеки
Проект Android Studio, который поддерживает C ++, имеет дополнительный каталог исходного кода cpp. Как вы могли догадаться, все файлы и библиотеки C ++ должны быть размещены внутри него. По умолчанию в каталоге есть файл native-lib.cpp. Пока что мы напишем весь наш код на C ++ внутри него.
В этом уроке мы создадим простую нативную библиотеку, содержащую функцию, которая вычисляет площадь круга с помощью формулы πr². Функция примет радиус круга как jdouble и вернет площадь как jstring .
Начните с добавления в файл директив include :
jni.h — это заголовочный файл, содержащий несколько макроопределений, типов, структур и функций, которые незаменимы при работе с NDK. (JNI означает Java Native Interface, и это среда, которая позволяет Java Runtime взаимодействовать с собственным кодом.) Заголовочный файл string необходим, потому что мы будем использовать тип jstring в нашей библиотеке. Заголовочный файл math.h содержит значение π.
По умолчанию для поддержки полиморфизма компилятор C ++ модифицирует имена всех функций, которые вы определяете в своем коде. Эта функция часто упоминается как изменение имени. Из-за манипуляции с именем вызов ваших функций C ++ из кода Java приведет к ошибкам. Чтобы избежать ошибок, вы можете отключить управление именами, указав свои функции внутри блока extern «C» .
Имена функций C ++, доступные через JNI, должны иметь следующий формат:
- Они должны иметь префикс Java_.
- Они должны содержать искаженную форму имени пакета, где точки заменяются символами подчеркивания.
- Они должны содержать имя класса Java, к которому они принадлежат.
Кроме того, вы должны указать видимость функции. Вы можете сделать это, используя макрос JNIEXPORT. По соглашению, большинство разработчиков также включают макрос JNICALL в определении функции, хотя в настоящее время он не служит никакой цели в Android.
Следующий код определяет функцию, называемую calculateArea , к которой можно получить доступ из класса Java, называемого MainActivity :
Обратите внимание, что помимо радиуса функция также принимает тип JNIEnv , который имеет функции утилиты, которые вы можете использовать для обработки типов Java, и экземпляр jobject , который является ссылкой на экземпляр MainActivity . Мы, конечно, будем создавать MainActivity позже в этом уроке.
Вычисление площади очень просто. Все, что вам нужно сделать, это умножить макрос M_PI на квадрат radius .
Просто чтобы вы знали, как обрабатывать строки при работе с JNI, давайте теперь создадим новую строку, содержащую сообщение о том, что такое площадь. Для этого вы можете использовать функцию sprintf() .
Поскольку Java не может напрямую обрабатывать массив символов C ++, возвращаемый тип нашей функции — jstring . Чтобы преобразовать массив output в объект jstring , вы должны использовать функцию NewStringUTF() .
На этом этапе наш код на C ++ готов.
4. Использование нативной библиотеки
На предыдущем шаге вы видели, что функция calculateArea() должна принадлежать классу Java MainActivity . Начните создавать класс, щелкнув правой кнопкой мыши имя вашего Java-пакета и выбрав File > New > Empty Activity.
В появившемся диалоговом окне назовите действие MainActivity. Убедившись, что опция Launcher Activity отмечена, нажмите кнопку Finish.
Перед тем, как его можно будет использовать, необходимо загрузить собственную библиотеку. Поэтому добавьте в класс static блок и загрузите библиотеку с помощью метода loadLibrary() класса System .
Чтобы иметь возможность использовать С++ функцию calculateArea() внутри действия, вы должны объявить ее как native метод.
Теперь вы можете использовать метод calculateArea() , как любой обычный метод Java. Например, вы можете добавить следующий код к методу onCreate() для вычисления и печати области круга с радиусом 5,5:
Если вы запустите приложение, вы сможете увидеть следующий вывод в окне logcat:
Заключение
В этом уроке вы узнали, как создать собственную C ++-библиотеку и использовать ее в приложении для Android. Стоит отметить, что собственный процесс сборки по умолчанию генерирует отдельный .so-файл для каждой архитектуры процессора, поддерживаемой NDK. Поэтому вы можете быть уверены, что ваше приложение будет работать на большинстве Android-устройств без каких-либо проблем.
Чтобы узнать больше об Android NDK, я предлагаю вам обратиться к руководству NDK.
И ознакомьтесь с некоторыми нашими другими учебниками и курсами по разработке Android!
Фоновый звук в Android с MediaSessionCompat
Сделайте снимки с помощью своего приложения для Android
Источник
Введение в Android NDK
Для разработки приложений под ОС Android, Google предоставляет два пакета разработки: SDK и NDK. Про SDK существует много статей, книжек, а так же хорошие guidelines от Google. Но про NDK даже сам Google мало что пишет. А из стоящих книг я бы выделил только одну, Cinar O. — Pro Android C++ with the NDK – 2012.
Эта статья ориентирована на тех, кто ещё не знаком (или мало знаком) с Android NDK и хотел бы укрепить свои знания. Внимание я уделю JNI, так как мне кажется начинать нужно именно с этого интерфейса. Так же, в конце рассмотрим небольшой пример с двумя функциями записи и чтения файла. Кто не любит много текста, тот может посмотреть видео версию.
Что такое Android NDK?
Android NDK (native development kit) – это набор инструментов, которые позволяют реализовать часть вашего приложения используя такие языки как С/С++.
Для чего используют NDK?
Google рекомендует прибегать к использованию NDK только в редчайших случаях. Зачастую это такие случаи:
- Нужно увеличить производительность (например, сортировка большого объема данных);
- Использовать стороннюю библиотеку. Например, много уже чего написано на С/С++ языках и нужно просто заиспользовать существующий материал. Пример таких библиотек, как, Ffmpeg, OpenCV;
- Программирование на низком уровне (например, всё что выходит за рамки Dalvik);
Что такое JNI?
Java Native Interface – стандартный механизм для запуска кода, под управлением виртуальной машины Java, который написан на языках С/С++ или Assembler, и скомпонован в виде динамических библиотек, позволяет не использовать статическое связывание. Это даёт возможность вызова функции С/С++ из программы на Java, и наоборот.
Преимущества JNI
Основное преимущество перед аналогами (Netscape Java Runtime Interface или Microsoft’s Raw Native Interface and COM/Java Interface) является то что JNI изначально разрабатывался для обеспечения двоичной совместимости, для совместимости приложений, написанных на JNI, для любых виртуальных машин Java на конкретной платформе (когда я говорю о JNI, то я не привязываюсь к Dalvik машине, потому как JNI был написан Oracle для JVM который подходит для всех Java виртуальных машин). Поэтому скомпилированный код на С/С++ будет выполнятся в не зависимости от платформы. Более ранние версии не позволяли реализовывать двоичную совместимость.
Двоичная совместимость или же бинарная совместимость – вид совместимости программ, позволяющий программе работать в различных средах без изменения её исполняемых файлов.
Как устроен JNI
JNI таблица, организована как таблица виртуальных функций в С++. VM может работать с несколькими такими таблицами. Например, одна будет для отладки, вторая для использования. Указатель на JNI интерфейс действителен только в текущем потоке. Это значит, что указатель не может гулять с одного потока в другой. Но нативные методы могут быть вызваны из разных потоков. Пример:
- *env – указатель на интерфейс;
- оbj – ссылка на объект в котором описан нативный метод;
- i and s – передаваемые аргументы;
Примитивные типы копируются между VM и нативным кодом, а объекты передаются по ссылке. VM обязана отслеживать все ссылки которые передаются в нативный код. Все переданные ссылки в нативный код не могут быть освобождены GC. Но нативный код в свою очередь должен информировать VM о том что ему больше не нужны ссылки на переданные объекты.
Локальные и глобальные ссылки
JNI делит ссылки на три типа: локальные, глобальные и слабые глобальные ссылки. Локальные действительны пока не завершиться метод. Все Java объекты которые возвращает функции JNI являются локальными. Программист должен надеется на то что VM сама подчистит все локальные ссылки. Локальные ссылки доступны лишь в том потоке в котором были созданы. Однако если есть необходимость то их можно освобождать сразу методом JNI интерфейса DeleteLocalRef:
Глобальные ссылки остаются пока они явно не будут освобождены. Что бы зарегистрировать глобальную ссылку следует вызвать метод NewGlobalRef. Если же глобальная ссылка уже не нужна, то её можно удалить методом DeleteGlobalRef:
Обработка ошибок
JNI не проверяет ошибки такие как NullPointerException, IllegalArgumentException. Причины:
- снижение производительности;
- в большинстве функций C библиотек очень и очень трудно защитится от ошибок.
JNI позволяет использовать Java Exception. Большинство JNI функций возвращают код ошибок а не сам Exception, и поэтому приходится обрабатывать сам код, а в Java уже выбрасывать Exception. В JNI следует проверять код ошибки вызываемых функций и после них следует вызвать ExceptionOccurred(), которая в свою очередь возвращает объект ошибки:
Например, некоторые функции JNI доступа к массивам не возвращают ошибки, но могут вызвать исключения ArrayIndexOutOfBoundsException или ArrayStoreException.
Примитивные типы JNI
В JNI существуют свои примитивные и ссылочные типы данных.
Java Type | Native Type | Description |
---|---|---|
boolean | jboolean | unsigned 8 bits |
byte | jbyte | signed 8 bits |
char | jchar | unsigned 16 bits |
short | jshort | signed 16 bits |
int | jint | signed 32 bits |
long | jlong | signed 64 bits |
float | jfloat | 32 bits |
double | jdouble | 64 bits |
void | void | N/A |
Ссылочные типы JNI
Модифицированный UTF-8
JNI использует модифицированную кодировку UTF-8 для представления строк. Java в свою очередь использует UTF-16. UTF-8 в основном используется в С, потому что он кодирует \u0000 в 0xc0, вместо привычной 0x00. Изменённые строки кодируются так, что последовательность символов, которые содержат только ненулевой ASCII символы могут быть представлены с использованием только одного байта.
Функции JNI
Интерфейс JNI содержит в себе не только собственный набор данных, но и свои собственные функции. На их рассмотрение уйдёт много времени, так как их не один десяток. Ознакомится с ними вы сможете в официальной документации.
Пример использования функций JNI
Небольшой пример, что бы вы усвоили пройденный материал:
Разберём построчно:
- JavaVM – предоставляет интерфейс для вызова функций, которые позволяют создавать и уничтожать JavaVM;
- JNIEnv – обеспечивает большинство функций JNI;
- JavaVMInitArgs – аргументы для JavaVM;
- JavaVMOption – опции для JavaVM;
Метод JNI_CreateJavaVM() инициализирует JavaVM и возвращает на неё указатель. Метод JNI_DestroyJavaVM() выгружает созданную JavaVM.
Потоки
Всеми потоками в Linux управляет ядро, но они могут быть прикреплены к JavaVM функциями AttachCurrentThread и AttachCurrentThreadAsDaemon. Пока поток не присоединён он не имеет доступа к JNIEnv. Важно, Android не приостанавливает потоки которые были созданы JNI, даже если срабатывает GC. Но перед тем как поток завершиться он должен вызвать метод DetachCurrentThread что бы отсоединиться от JavaVM.
Первые шаги
Структура проекта у вас должна выглядеть следующим образом:
Как мы видим из рисунка 3, весь нативный код находится в папке jni. После сборки проекта, в папке libs создастся четыре папки под каждую архитектуру процессора, в которой будет лежать ваша нативная библиотека (количество папок зависит от количество выбранных архитектур).
Для того, чтобы создать нативный проект, нужно создать обычный Android проект и проделать следующие шаги:
- В корне проекта нужно создать папку jni, в которую поместить исходники нативного кода;
- Создать файл Android.mk, который будет собирать проект;
- Создать файл Application.mk, в котором описываются детали сборки. Он не является обязательным условием, но позволяет гибко настроить сборку;
- Создать файл ndk-build, который будет запускать процесс сборки (тоже не является обязательным).
Android.mk
Как упоминалось уже выше, это make файл для сборки нативного проекта. Android.mk позволяет группировать ваш код в модули. Модули могут быть как статические библиотеки (static library, только они будут скопированные в ваш проект, в папку libs), разделяемые библиотеки (shared library), автономный исполняемый файл (standalone executable).
Пример минимальной конфигурации:
Рассмотрим детально:
- LOCAL_PATH := $(call my-dir) – функция call my-dir возвращает путь папки в которой вызывается файл;
- include $(CLEAR_VARS) – очищает переменные которые использовались до этого кроме LOCAL_PATH. Это необходимо так как все переменные являются глобальными, потому что сборка происходит в контексте одного GNU Make;
- LOCAL_MODULE – имя выходного модуля. В нашем примере имя выходной библиотеки установлено как NDKBegining, но после сборки в папке libs создадутся библиотеки с именами libNDKBegining. Android добавляет к названию префикс lib, но в java коде при подключении вы должны указывать название библиотеки без префикса (то есть названия должны совпадать с установленными в make файлах);
- LOCAL_SRC_FILES – перечисление исходных файлов из которых следует создать сборку;
- include $(BUILD_SHARED_LIBRARY) – указывает тип выходного модуля.
В Android.mk можно определить свои переменные, но они не должны иметь такой синтаксис: LOCAL_, PRIVATE_, NDK_, APP_, my-dir. Google, рекомендует называть свои переменные, как MY_. Например:
Application.mk
NDK-BUILDS
Ndk-build из себя представляет обёртку GNU Make. После 4-й версии ввели флаги для ndk-build:
- clean – очищает все сгенеренные бинарные файлы;
- NDK_DEBUG=1 – генерирует отладочный код;
- NDK_LOG=1 – показывает лог сообщений (используется для отладки);
- NDK_HOST_32BIT=1 – Android имеет средства для поддержки 64-х битных версий утилит (например NDK_PATH\toolchains\mipsel-linux-android-4.8\prebuilt\windows-x86_64 и т.д.);
- NDK_APPLICATION_MK — указывается путь к Application.mk.
В 5-й версии NDK был введён такой флаг как NDK_DEBUG. Если он установлен в 1 то создаётся отладочная версия. Если флаг не установлен то ndk-build по умолчанию проверяет стоит ли атрибут android:debuggable=«true» в AndroidManifest.xml. Если вы используете ndk выше 8-й версии, то Google не рекомендует использовать атрибут android:debuggable в AndroidManifest.xml (потому что если вы используете «ant debug» или строите отладочную версию с помощью ADT плагина то они автоматически добавляют флаг NDK_DEBUG=1).
По умолчанию устанавливается поддержка 64-х разрядной версии утилит, но вы можете принудительно собрать только для 32-х установив флаг NDK_HOST_32BIT=1. Google, рекомендует всё же использовать 64-х разрядность утилит для повышения производительности больших программ.
Как собрать проект?
Раньше это было мучением. Нужно было установить CDT плагин, скачать компилятор cygwin или mingw. Скачать Android NDK. Подключить это всё в настройках Eclipse. И как на зло это всё оказывалось не рабочим. Я первый раз когда столкнулся с Android NDK, то настраивал это всё 3 дня (а проблема оказалось в том что в cygwin нужно было дать разрешение 777 на папку проекта).
Сейчас с этим всё намного проще. Идёте по этой ссылке. Качаете Eclipse ADT Bundle в котором уже есть всё то что необходимо для сборки.
Вызов нативных методов из Java кода
Для того что бы использовать нативный код из Java вам сперва следует определить нативные методы в Java классе. Например:
Перед методом следует поставить зарезервированное слово «native». Таким образом компилятор знает, что это точка входа в JNI. Эти методы нам нужно реализовать в С/С++ файле. Так же Google рекомендует начинать именовать методы со слова nativeХ, где Х – реальное название метода. Но перед тем как реализовывать эти методы вручную, следует сгенерировать header файл. Это можно сделать вручную, но можно использовать утилиту javah, которая находится в jdk. Но пойдём дальше и не будет использовать её через консоль, а будем это делать при помощи стандартных средств Eclipse.
Теперь можете запускать. В директории bin/classes будут лежать ваши header файлы.
Далее копируем эти файлы в jni директорию нашего нативного проекта. Вызываем контекстное меню проекта и выбираем пункт Android Tools – Add Native Library. Это позволит нам использовать jni.h функции. Дальше вы уже можете создавать cpp файл (иногда Eclipse его создаёт по умолчанию) и писать тела методов, которые уже описаны в header файле.
Пример кода я не стал добавлять в статью, чтобы не растягивать её. Пример вы можете посмотреть/скачать с github.
Источник