Содержание

Создание приложения Android Native Activity

Twitter LinkedIn Facebook Адрес электронной почты

  • Статья

После установки кроссплатформенной рабочей нагрузки

Разработка мобильных приложений на языке C++ Visual Studio можно использовать для создания полнофункциональных приложений Android Native Activity. Пакет Android Native Development Kit (NDK) — это набор средств, с помощью которых можно реализовывать большинство возможностей приложения Android, используя чистый код C или C++. Для обеспечения взаимодействия кода C или C++ с Android используется определенный код Java JNI, выступающий в роли связующего. В Android NDK появилась возможность создавать приложения Native Activity с помощью API Android уровня 9. Код Native Activity популярен для создания игровых приложений и приложений с интенсивным использованием графики на основе Unreal Engine или OpenGL. В этом пошаговом руководстве показано создание простого приложения Native Activity, в котором используется OpenGL. В дополнительных разделах последовательно рассматриваются такие этапы жизненного цикла разработки, как редактирование, сборка, отладка и развертывание кода Native Activity.

Требования

Прежде чем создавать приложение Android Native Activity, необходимо убедиться, что вы выполнили все системные требования и установили рабочую нагрузку Разработка мобильных приложений на языке C++ в Visual Studio. Дополнительные сведения см. в статье Установка Visual C++ для разработки кроссплатформенных мобильных приложений на языке C++. Убедитесь, что необходимые сторонние инструменты и пакеты SDK включены в установку, а также что установлен эмулятор Android.

Создание проекта Native Activity

В этом руководстве вы сначала создадите новый проект Android Native Activity, а затем создадите и запустите приложение по умолчанию в эмуляторе Android.

  1. В Visual Studio выберите Файл>Создать>Проект.

  2. В диалоговом окне Новый проект в меню Шаблоны последовательно выберите

    Visual C++>Кроссплатформенное приложение, а затем выберите шаблон Приложение Native-Activity (Android).

  3. Присвойте приложению имя, например MyAndroidApp, а затем нажмите OK.

    Visual Studio создаст новое решение и откроет обозреватель решений.

  1. В Visual Studio выберите Файл>Создать>Проект.

  2. В диалоговом окне Создание нового проекта выберите шаблон

    Приложение Native-Activity (Android), а затем нажмите Далее.

  3. В диалоговом окне Настроить новый проект введите имя, например MyAndroidApp в разделе Имя проекта, а затем выберите Создать.

    Visual Studio создаст новое решение и откроет обозреватель решений.

В новое решение приложения Android Native Activity входят два проекта.

  • MyAndroidApp.NativeActivity содержит ссылки и связующий код для запуска приложения как приложения Native Activity на Android. Реализация точек входа из кода glue находятся в main.cpp. Предварительно скомпилированные заголовки находятся в

    файле pch.h. Этот проект приложения native Activity компилируется в файл SO общей библиотеки, который выбирается проектом упаковки.

  • MyAndroidApp.Packaging создает файл с расширением .apk для развертывания на устройстве или в эмуляторе Android. Он содержит ресурсы и файлAndroidManifest.xml , в котором задаются свойства манифеста. Он также содержит файлbuild.xml , который управляет процессом сборки Ant. По умолчанию он задан как начальный проект, который можно развернуть и запустить непосредственно из Visual Studio.

Создание и запуск приложения Android Native Activity по умолчанию

Разработайте и запустите приложение, созданное шаблоном, чтобы проверить установку и настройку. Для первоначального теста запустите приложение в одном из профилей устройств, установленных эмулятором Android. Если вы предпочитаете тестировать приложение на другой платформе, загрузите целевой эмулятор или подключите устройство к компьютеру.

Сборка и запуск приложения Native Activity по умолчанию

  1. Если он еще не выбран, выберите x86 в раскрывающемся списке Платформы решений .

    Если список Платформы решения не отображается, щелкните пункт Платформы решения из раскрывающегося списка Добавить или удалить кнопки и выберите свою платформу.

  2. В строке меню последовательно выберите Сборка>Собрать решение.

    В окне «Выходные данные» отобразятся выходные данные процесса сборки для двух проектов в решении.

  3. Выберите один из профилей эмулятора Android в качестве цели развертывания.

    Если вы установили другие эмуляторы или подключили устройство Android, то можете выбрать их в раскрывающемся списке платформы развертывания.

  4. Нажмите клавишу F5 , чтобы начать отладку, или SHIFT+F5 , чтобы начать работу без отладки.

    Вот как выглядит приложение по умолчанию в эмуляторе Android.

    Visual Studio запускает эмулятор, который за несколько секунд загружает и развертывает код. После запуска приложения можно задать точки останова и использовать отладчик для проверки кода, языковых стандартов и контрольных значений.

  5. Нажмите клавишу SHIFT+F5 , чтобы остановить отладку.

    Эмулятор является отдельным процессом, который продолжает выполняться. Вы можете изменять, компилировать и развертывать код несколько раз в одном эмуляторе.

Использование кода C и C ++ в приложении Android с NDK

В этом уроке я представлю еще один вариант разработки для вашего следующего проекта Android, который идеально подходит для команд с унаследованным кодом или имеющимися знаниями в C и C ++. Android Native Development Kit (NDK) является частью официального набора инструментов Google, и мы рассмотрим, когда NDK может быть полезен и как его использовать в приложении для Android.

Что такое НДК?

NDK – это набор инструментов, который позволяет разрабатывать приложения для Android с использованием C, C ++ и других родных языков кода, компилируя код в приложения, которые могут работать на устройствах Android. Использование NDK, как правило, не рекомендуется, поскольку приложения могут испытывать снижение производительности, страдать от проблем совместимости, затруднять отладку и снижать гибкость. То, что гарантирует NDK, – это увеличение сложности приложения и возможности подключения из-за взаимодействия с нативным кодом.

Предыдущие высказывания могут показаться обескураживающими, но есть хорошие примеры использования NDK. Это включает в себя вычислительные приложения, такие как игры, игровые движки, обработку сигналов и физические симуляции. Еще один хороший пример использования – повторное использование существующих библиотек, написанных на C / C ++. Это означает, что вы можете использовать большую коллекцию библиотек собственного кода, доступных онлайн.

Убедитесь в том, чтобы сбалансировать плюсы и минусы использования NDK, прежде чем решить, стоит ли это дополнительной сложности. Вы никогда не должны основывать свое решение на предпочитаемом вами языке, даже если вы являетесь экспертом в C или C ++.

Использование NDK

Android Studio

Если у вас его еще нет, загрузите Android Studio , официальную IDE от Google.

Пакет НДК

Android Studio включает только стандартные инструменты и SDK, поэтому загружайте и устанавливайте пакет NDK отдельно. Есть два способа сделать это. Первый и самый простой – это опция автоматической установки на вкладке Инструменты SDK . Это большая загрузка (~ 1 ГБ), поэтому убедитесь, что у вас хорошее интернет-соединение и / или терпение.

Второй способ – загрузить NDK вручную со страницы загрузок NDK . Это экономит некоторое время из-за меньшего размера загрузки (<.5 ГБ), но потребует некоторой настройки. Загрузите соответствующий пакет NDK для вашей платформы и следуйте инструкциям по установке. Вы можете поместить извлеченный пакет куда угодно, но запомните это местоположение, так как оно понадобится вам позже.

Привет, мир

Давайте запустим тестовый проект, чтобы увидеть, работает ли установка NDK. Папка пакета NDK содержит примеры, но, похоже, они не работают “из коробки” в Android Studio без дополнительной настройки. Вместо этого мы импортируем образцы, которые работают с экрана приветствия . Эти образцы NDK из GitHub также могут быть загружены или клонированы напрямую. Эта коллекция образцов лучше совместима с последней версией Android Studio.

Выберите « Импортировать пример кода Android» и введите hello в поле поиска, чтобы отфильтровать список. Выберите Hello JNI из отфильтрованного списка в категории Ndk . Нажмите « Далее», чтобы изменить имя приложения и местоположение проекта, затем нажмите « Готово» .

JNI

После загрузки кода и синхронизации Gradle, давайте посмотрим на итоговую структуру проекта. Вы могли заметить несоответствие в названии проекта. Почему он называется HelloJNI, а не HelloNDK ? Что такое «JNI» и чем он отличается от «NDK»? «Собственный интерфейс Java» – это инфраструктура, которая позволяет приложениям Java взаимодействовать с собственным кодом. JNI и NDK работают вместе, чтобы обеспечить встроенную поддержку приложений Android. NDK является частью платформы Android, в то время как JNI доступен для любого приложения Java, а не только для приложений Android.

Внутри проекта находится папка с именем jni, которая будет содержать весь исходный код приложения на C или C ++. JNI обеспечивает двусторонний интерфейс. Код C / C ++ может вызывать код Java, включая стандартные библиотеки Android, а код Java может вызывать собственные функции, определенные в коде C / C ++. Собственный код регулируется теми же песочницами и правилами безопасности, что и код Java, поэтому у приложения не будет полного неограниченного доступа к оборудованию. Для более подробного обсуждения JNI, прочитайте статьи JNI с сайта Android Developer .

ABI

Давайте создадим и запустим проект на эмуляторе или экспортируем APK для тестирования на устройстве. Вот hello-jni, работающий на моем Asus Zenfone, который использует двоичный интерфейс приложений Intel или x86 (ABI). Когда приложение взаимодействует с собственным кодом, оно должно поддерживать разные архитектуры ЦП. Это означает, что он должен быть скомпилирован для каждой платформы, на которой вы хотите его запустить.

Каждый ABI соответствует целевой архитектуре, определяющей, как собственный код приложения должен вести себя или взаимодействовать с системой во время выполнения. В настоящее время NDK поддерживает архитектуры ARMEABI (по умолчанию), MIPS и x86. Обычно проект необходимо настроить вручную, а собственный код создается для каждой платформы. Об этом уже заботятся в примере проекта, поэтому просто повторно используйте образец и установите его в качестве отправной точки для проекта. В нем уже есть все основные требования, чтобы приложение могло взаимодействовать с NDK.

Повторное использование библиотек

Как упоминалось ранее, сила NDK заключается в его способности повторно использовать существующие, проверенные временем и мощные библиотеки C / C ++. Эта функция находится на экспериментальной стадии в Android Studio и обычно рекомендуется для опытных разработчиков. Тем не менее, это что-то интересное и заслуживающее изучения.

SDL

Simple DirectMedia Layer – это библиотека аппаратных абстракций с открытым исходным кодом, выпущенная 18 лет назад. Он используется в основном для игр, но может использоваться для всего, что связано с высокопроизводительной графикой. В этом разделе мы создадим базовый проект, который использует SDL и может использоваться в качестве шаблона для более сложных проектов в будущем.

Настройка проекта

Первым шагом является загрузка исходного кода SDL со страницы загрузки исходного кода или клонирование репозитория Mercurial с помощью:

hg clone http://hg.libsdl.org/SDL

После завершения загрузки или клонирования импортируйте пример проекта Android (с именем android-project ) из папки SDL в Android Studio, принимая значения по умолчанию на экранах импорта. После создания проекта может возникнуть проблема синхронизации, связанная с отсутствующей версией SDK. Чтобы решить эту проблему, откройте SDK Manager и загрузите соответствующую версию SDK для проекта. В данном случае Android 3.1 (API Level 12). Установите флажок Показать сведения о пакете, чтобы открыть эту версию, поскольку она помечена как устаревшая. Можно использовать более свежую версию, но пока давайте придерживаться Android-12, чтобы все было просто.

После установки SDK проект должен синхронизироваться без ошибок, отображая сообщение BUILD SUCCESSFUL на консоли. Если вы столкнулись с какими-либо другими ошибками, пожалуйста, дайте мне знать в комментариях.

Gradle

Android Studio использует Gradle , систему автоматизации сборки с открытым исходным кодом для управления проектами и их выводом. Большая часть конфигурации проекта происходит в файлах Gradle. Давайте добавим некоторую ручную настройку в проект.

Откройте build.gradle (модуль приложения) и добавьте следующий код под свойством buildToolsVersion

    sourceSets {
        main {
            jni.srcDirs = []
        }
    }

Это скроет собственный код в проводнике проекта, который помогает вручную создавать SDL и собственный код с помощью ndk-buildпапки ndk-bundle . Сборка собственного кода вручную – более надежный метод по сравнению с автоматизированными сборками с использованием Android Studio и Gradle. Поддержка Gradle для NDK все еще является экспериментальной, и не все варианты использования обрабатываются.

Символическая ссылка

Давайте создадим символическую ссылку внутри папки app / src / main / jni / проекта. Назовите его SDL и укажите его на папку SDL, загруженную или клонированную ранее. Папка SDL может быть скопирована напрямую, но этот метод менее эффективен и подвержен ошибкам. Исходные файлы скрыты в Android Studio, поэтому их необходимо открыть вручную во внешнем редакторе для внесения следующих изменений.

Android.mk

Android.mk – это простой файл make, который описывает исходный код проекта и общие библиотеки для системы сборки. Проект, который уже импортирован, имеет эти файлы создания по умолчанию, но с минимальной необходимой конфигурацией. Давайте внесем изменения в файл Android.mk основного приложения. Этот файл находится в папке app / src / main / jni / src . Найдите строку с надписью YourSourceHere.cmain.c

Application.mk

Файл make Application.mk содержит конфигурацию, общую для всех модулей, и влияет на сборку всего проекта. Добавьте следующую строку в Application.mk внутри папки app / src / main / jni / :

APP_PLATFORM := android-12

Этот параметр свойства сообщает ndk-build Еще один параметр для изменения в Application.mk – это дополнительные целевые платформы, использующие свойство APP_ABI Выберите платформы из следующих или добавьте их все:

  • arm64-V8A
  • armeabi
  • armeabi-v7a
  • MIPS
  • MIPS64
  • x86
  • x86_64

Добавление поддержки для всех этих платформ дает приложению более широкий охват, но в результате получится более крупный APK.

main.c

Последний шаг – добавить пользовательский код, который инициализирует SDL и вызывает его функции, чтобы увидеть, работает ли проект. Для удобства давайте повторно используем этот файл main.c , загружая его в папку app / src / main / jni / src .

Открыв main.c , вы заметите, что он пытается загрузить и отобразить изображение с именем image.bmp . Чтобы поддержать это, создайте папку с именем asset внутри app / src / main и добавьте растровое изображение с именем image.bmp . Я использовал логотип SitePoint.com для этого теста.

Сборка и запуск

Используя терминал, откройте app / src / main / jni / и запустите ndk-build NDK_LIBS_OUT=../jniLibs Эта команда создает собственный код и сохраняет полученные файлы общего объекта ( .so ) в папку jniLibs . Если ndk-build После завершения сборки переключитесь на Android Studio и вручную запустите синхронизацию, используя пункт меню Сервис -> Android -> Синхронизировать проект с файлами Gradle . APK теперь можно создать с помощью пункта меню Build -> Build APK, чтобы протестировать приложение на устройстве или эмуляторе. Вот моя сборка, работающая на архитектуре x86:

Вывод

Как мы уже видели, использование NDK с нативным кодом в приложении для Android требует некоторой работы, но приносит новый потенциал. Надеюсь, я показал вам достаточно, чтобы оценить, подходит ли он для вашего проекта или нет.

Я хотел бы услышать ваш опыт и мнения об использовании кода C и C ++ с Android NDK в комментариях ниже.

Добавьте в проект код C и C++ | Android Studio

Добавьте код C и C++ в свой проект Android, поместив код в каталог cpp в вашем модуле проекта. Когда вы строите свой проект, это код компилируется в нативную библиотеку, которую Gradle может упаковать с вашим приложением. Затем ваш код Java или Kotlin может вызывать функции в вашей родной библиотеке. через собственный интерфейс Java (JNI). Чтобы узнать больше об использовании JNI Framework, прочитайте советы JNI для Андроид.

Android Studio поддерживает CMake, что полезно для кроссплатформенных проектов. Android Studio также поддерживает ndk-build , который может быть быстрее, чем CMake, но поддерживает только Android. Используя как CMake, так и ndk-build в том же модуле в настоящее время не поддерживается.

Чтобы импортировать существующую библиотеку ndk-build в вашу Android Studio проект, научитесь свяжите Gradle с вашим родным проектом библиотеки.

На этой странице показано, как настроить Android Studio с помощью необходимые инструменты сборки, создайте новый проект на C/C++ поддержки и добавляйте в проект новые файлы C/C++.

Если вместо этого вы хотите добавить собственный код в существующий проект, Следуй этим шагам:

  1. Создайте новые собственные исходные файлы и добавьте файлы в ваш проект Android Studio.
    • Пропустите этот шаг, если у вас уже есть собственный код или вы хотите импортировать предварительно созданную нативную библиотеку.
  2. Настройте CMake для встройте свой собственный исходный код в библиотеку. Этот скрипт сборки требуется если вы импортируете и связываете готовые или платформенные библиотеки.
    • Если у вас есть собственная библиотека, для которой уже CMakeLists.txt скрипт сборки или использует ndk-build и включает Android.mk скрипт сборки, пропустите этот шаг.
  3. Настроить Gradle, указав путь к вашему CMake или ndk-build . файл сценария. Gradle использует скрипт сборки для импорта исходного кода в ваш Проект Android Studio и упакуйте свою собственную библиотеку в приложение.

После того, как вы настроите свой проект, получите доступ к своим собственным функциям из Код Java или Kotlin с использованием фреймворка JNI. Чтобы создать и запустить приложение, нажмите Выполнить .

Примечание: Если в существующем проекте используется Инструмент ndkCompile , перейдите на использование CMake или ndk-сборка .

Загрузите NDK и инструменты сборки

Чтобы скомпилировать и отладить собственный код для вашего приложения, вам потребуется следующее компоненты:

  • Родной комплект разработки для Android (NDK): набор инструментов, позволяющий использовать код C и C++ с Андроид. NDK предоставляет библиотеки платформ, которые позволяют управлять собственными действий и доступа к физическим компонентам устройства, таким как датчики и сенсорные вход.
  • CMake: внешний инструмент сборки, который работает вместе с Gradle для создания собственного библиотека. Вам не нужен этот компонент, если вы планируете использовать только ndk-сборка .
  • LLDB: отладчик в Android Studio, который отлаживает нативный код.

Сведения об установке этих компонентов см. в разделе Установка и настройка NDK и CMake.

Создать новый проект с поддержкой C/C++

Чтобы создать новый проект с поддержкой собственного кода, процесс аналогичен создание любого другого Android Студийный проект, но с дополнительным шагом:

  1. В разделе мастера выберите свой проект , выберите тип проекта Native C++ .
  2. Нажмите Далее .
  3. Заполните все остальные поля в следующем разделе мастера.
  4. Щелкните Далее .
  5. В разделе мастера Customize C++ Support можно настроить ваш проект с полем C++ Standard .
    • Используйте раскрывающийся список, чтобы выберите, какую стандартизацию C++ вы хотите использовать. Выбор цепочки инструментов По умолчанию использует настройку CMake по умолчанию.
  6. Щелкните Готово .

После того, как Android Studio завершит создание нового проекта, откройте Project в левой части IDE и выберите Android вид из меню. Как показано на рисунке 1, Android Studio добавляет группу cpp :

Рисунок 1. групп представлений Android для собственных источников и внешние скрипты сборки.

Примечание: Это представление не отражает фактическую файловую иерархию. на диске, но группирует похожие файлы, чтобы упростить навигацию по вашему проекту.

В группе cpp вы можете найти все родные исходные файлы, заголовки, скрипты сборки для CMake или ndk-build и готовые библиотеки, которые являются частью вашего проекта. Для новых проектов Android Studio создает образец исходного файла C++, native-lib.cpp , и помещает его в каталоге src/main/cpp/ вашего модуля приложения. Этот образец код предоставляет простую функцию C++, stringFromJNI() , что возвращает строку "Привет с C++" . Узнайте, как добавить дополнительные исходные файлы в ваш проект в разделе о том, как создавать новые собственные исходные файлы.

Подобно тому, как файлы build.gradle инструктируют Gradle, как собирать ваше приложение, CMake и ndk-build требуют скрипта сборки, чтобы знать, как собирать ваша родная библиотека. Для новых проектов Android Studio создает сборку CMake. script, CMakeLists.txt и помещает его в корневой каталог вашего модуля. Чтобы узнать больше о содержимом этого скрипта сборки, прочитайте Настройте CMake.

Создайте и запустите образец приложения

Когда вы нажимаете , запускаете , Android Studio создает и запускает приложение, которое отображает текст «Привет с C++» на вашем Android-устройство или эмулятор. В следующем обзоре описаны события, которые происходит для сборки и запуска примера приложения:

  1. Gradle вызывает ваш внешний скрипт сборки, CMakeLists.txt .
  2. CMake следует командам в сценарии сборки для компиляции исходного кода C++. файл, натив-lib.cpp , в общую библиотеку объектов и имена это libnative-lib.so . Затем Gradle упаковывает его в приложение.
  3. Во время выполнения приложение MainActivity загружает собственный библиотека с использованием System. loadLibrary() . Родная функция библиотеки, stringFromJNI() , теперь доступно для приложения.
  4. MainActivity.onCreate() вызовы stringFromJNI() , который возвращает "Hello from C++" и использует его для обновления TextView .

Чтобы убедиться, что Gradle упаковывает нативную библиотеку в приложение, используйте Анализатор APK:

  1. Выберите Build > Build Bundle(s) / APK(s) > Build APK(s) .
  2. Выберите «Сборка » > «Анализ APK ».
  3. Выберите APK или AAB из каталога app/build/outputs/. и нажмите OK .
  4. Как показано на рисунке 2, вы можете увидеть libnative-lib.so в Окно APK Analyzer под lib// .

    Рисунок 2. Найдите собственную библиотеку с помощью APK Анализатор.

Совет: Если вы хотите поэкспериментировать с другими приложениями Android, использовать собственный код, нажмите File > New > Import Sample и выберите образец проекта из списка Ndk .

Создание новых исходных файлов C/C++

Чтобы добавить новые исходные файлы C/C++ в существующий проект, выполните следующие действия:

  1. Если у вас еще нет каталога cpp/ в основном источнике набор вашего приложения, создайте его следующим образом:
    1. Откройте панель Project в левой части IDE и выберите в меню вид Project .
    2. Перейдите к ваш-модуль > src .
    3. Щелкните правой кнопкой мыши основной каталог и выберите Создать > Справочник .
    4. Введите cpp в качестве имени каталога и нажмите OK .
  2. Щелкните правой кнопкой мыши каталог cpp/ и выберите Создать > Исходный файл C/C++ .
  3. Введите имя исходного файла, например native-lib .
  4. В меню введите выберите расширение файла для исходного файла, например .cpp .
    • Нажмите Редактировать типы файлов чтобы добавить другие типы файлов в меню, такие как .cxx или .hxx . В новых расширениях файлов В появившемся диалоговом окне выберите другое расширение файла из Расширение источника и Расширение заголовка меню и нажмите OK .
  5. Чтобы создать файл заголовка, выберите Создать связанный заголовок флажок.
  6. Щелкните OK .

После добавления в проект новых файлов C/C++ вам все равно необходимо настроить CMake для включения файлов в ваша родная библиотека.

Дополнительные ресурсы

Чтобы узнать больше о поддержке кода C/C++ в вашем приложении, попробуйте следующее. ресурс.

Codelabs

  • Создание Hello-CMake с помощью Android Studio В этой лаборатории кода показано, как использовать шаблон Android Studio CMake для запуска Разработка проекта Android NDK.

Свяжите Gradle со своей родной библиотекой | Android-студия

Чтобы включить ваш собственный проект библиотеки в качестве зависимости сборки Gradle, вам нужно чтобы предоставить Gradle путь к файлу сценария CMake или ndk-build. Когда вы создаете свое приложение, Gradle запускает CMake или ndk-build, а пакеты библиотеки с вашим приложением. Gradle также использует скрипт сборки, чтобы узнать, какие файлы втянуть в свой проект Android Studio, чтобы вы могли получить к ним доступ из Окно пр. . Если у вас нет скрипта сборки для родного исходники, необходимо создать Сценарий сборки CMake, прежде чем продолжить.

Каждый модуль в вашем проекте Android может быть связан только с одним CMake или ndk-build. файл сценария. Так, например, если вы хотите собрать и упаковать выходные данные из несколько проектов CMake, вам нужно использовать один файл CMakeLists.txt как ваш скрипт сборки CMake верхнего уровня (с которым вы затем связываете Gradle) и добавить другие проекты CMake как зависимости этого скрипта сборки. Точно так же, если вы используете ndk-build, вы может включать другие файлы Makefile в ваш файл верхнего уровня. Android.mk файл скрипта.

Как только вы свяжете Gradle с нативным проектом, Android Studio обновит Панель Project для отображения исходных файлов и собственных библиотек. в группе cpp , а ваши внешние скрипты сборки в группе Группа Внешние файлы сборки .

Примечание. При внесении изменений в конфигурацию Gradle обязательно примените изменения, нажав Sync Project на панели инструментов. Кроме того, при внесении изменений в CMake или ndk-build script после того, как вы уже связали его с Gradle, вы должны синхронизировать Android Studio с вашими изменениями, выбрав Сборка > Обновить связанный C++ Проекты из строки меню.

Вы можете связать Gradle с внешним проектом CMake или ndk-build, используя Пользовательский интерфейс Android-студии:

  1. Откройте панель Project с левой стороны IDE и выберите вид Android .
  2. Щелкните правой кнопкой мыши модуль, который вы хотите связать со своей собственной библиотекой, например модуль app , и выберите Link C++ Project с Gradle из меню. Вы должны увидеть диалоговое окно, похожее на тот, что показан на рисунке 4.
  3. В раскрывающемся меню выберите CMake или . ndk-сборка .
    1. При выборе CMake используйте поле рядом с Путь к проекту для указания сценария CMakeLists.txt . файл для вашего внешнего проекта CMake.
    2. Если вы выберете ndk-build , используйте поле рядом с Project Path для указания файла сценария Android.mk для ваш внешний проект ndk-build. Android Studio также включает в себя Application.mk файл, если он находится в том же каталоге, что и ваш Файл Android.mk .

    Рисунок 4. Связывание внешнего проекта C++ с помощью Диалоговое окно Android Studio.

  4. Щелкните OK .

Настроить Gradle вручную

Чтобы вручную настроить Gradle для ссылки на вашу собственную библиотеку, вам нужно добавить в Блок externalNativeBuild на уровне вашего модуля build. gradle и настройте его с помощью cmake или Блок ndkBuild :

Groovy 

андроид {
  ...
  defaultConfig {...}
  типы сборки {...}
  // Инкапсулирует ваши внешние собственные конфигурации сборки.
  externalNativeBuild {
    // Инкапсулирует ваши конфигурации сборки CMake.
    сделай {
      // Предоставляет относительный путь к вашему скрипту сборки CMake.
      путь "CMakeLists.txt"
    }
  }
}

Котлин 

андроид {
  ...
  defaultConfig {...}
  типы сборки {...}
  // Инкапсулирует ваши внешние собственные конфигурации сборки.
  externalNativeBuild {
    // Инкапсулирует ваши конфигурации сборки CMake.
    сделай {
      // Предоставляет относительный путь к вашему скрипту сборки CMake.
      путь = файл ("CMakeLists.txt")
    }
  }
}

Примечание: Если вы хотите связать Gradle с существующей сборкой ndk проект, используйте Блок ndkBuild вместо cmake block и укажите относительный путь к вашему файлу Android. mk . Грейдл также включает файл Application.mk , если он находится в том же каталоге, что и ваш файл Android.mk .

Укажите дополнительные конфигурации

Вы можете указать необязательные аргументы и флаги для CMake или ndk-build с помощью настройка другого externalNativeBuild блок внутри defaultConfig блок вашего уровня модуля Файл build.gradle . Аналогично другим свойствам в defaultConfig , вы можете переопределить эти свойства для каждого вкус продукта в вашей конфигурации сборки.

Например, если ваш проект CMake или ndk-build определяет несколько собственных библиотеки и исполняемые файлы, вы можете использовать нацелен на свойство для создания и упаковки только подмножества этих артефакты для данного вкуса продукта. В следующем примере кода описывается некоторые из свойств, которые вы можете настроить:

Groovy 

андроид {
  ...
  defaultConfig {
    ...
    // Этот блок отличается от того, который вы используете для связывания Gradle
    // в ваш скрипт CMake или ndk-build.
    externalNativeBuild {
      // Для ndk-build вместо этого используйте блок ndkBuild.
      сделай {
        // Передает необязательные аргументы в CMake.
        аргументы "-DANDROID_ARM_NEON=TRUE", "-DANDROID_TOOLCHAIN=clang"
        // Устанавливает флаг для включения макроконстант формата для компилятора C.
        cFlags "-D__STDC_FORMAT_MACROS"
        // Устанавливает необязательные флаги для компилятора C++.
        cppFlags "-fexceptions", "-frtti"
      }
    }
  }
  типы сборки {...}
  вкус продукта {
    ...
    демо {
      ...
      externalNativeBuild {
        сделай {
          ...
          // Указывает, какие нативные библиотеки или исполняемые файлы нужно собрать и упаковать
          // для вкуса этого продукта.  Следующее говорит Gradle построить только
          // "native-lib-demo" и "my-executible-demo" выводятся из связанного
          // CMake-проект. Если вы не настроите это свойство, Gradle создаст все
          // исполняемые файлы и общие библиотеки объектов, которые вы определяете в своем CMake
          // (или ndk-build) проект. Однако по умолчанию Gradle упаковывает только
          // общие библиотеки в вашем приложении.
          нацелен на "native-lib-demo",
                  // Вам нужно указать этот исполняемый файл и его источники в вашем CMakeLists.txt
                  // с помощью команды add_executable(). Однако создание исполняемых файлов из вашего
                  // собственные исходные коды необязательны, и сборка собственных библиотек для упаковки в них
                  // ваше приложение удовлетворяет большинству требований проекта.
                  "моя-исполняемая-демо"
        }
      }
    }
    оплаченный {
      ...
      externalNativeBuild {
        сделай {
          . ..
          нацелены на «оплаченную нативную библиотеку»,
                  "мой-исполняемый-оплаченный"
        }
      }
    }
  }
  // Используйте этот блок, чтобы связать Gradle с вашим скриптом CMake или ndk-build.
  externalNativeBuild {
    сделать {...}
    // или ndkBuild {...}
  }
}

Котлин 

андроид {
  ...
  defaultConfig {
    ...
    // Этот блок отличается от того, который вы используете для связывания Gradle
    // в ваш скрипт CMake или ndk-build.
    externalNativeBuild {
      // Для ndk-build вместо этого используйте блок ndkBuild.
      сделай {
        // Передает необязательные аргументы в CMake.
        аргументы += listOf("-DANDROID_ARM_NEON=TRUE", "-DANDROID_TOOLCHAIN=clang")
        // Устанавливает флаг для включения макроконстант формата для компилятора C.
        cFlags += listOf("-D__STDC_FORMAT_MACROS")
        // Устанавливает необязательные флаги для компилятора C++.
        cppFlags += listOf("-fexceptions", "-frtti")
      }
    }
  }
  типы сборки {. ..}
  вкус продукта {
    ...
    создать ("демо") {
      ...
      externalNativeBuild {
        сделай {
          ...
          // Указывает, какие нативные библиотеки или исполняемые файлы нужно собрать и упаковать
          // для вкуса этого продукта. Следующее говорит Gradle построить только
          // "native-lib-demo" и "my-executible-demo" выводятся из связанного
          // CMake-проект. Если вы не настроите это свойство, Gradle создаст все
          // исполняемые файлы и общие библиотеки объектов, которые вы определяете в своем CMake
          // (или ndk-build) проект. Однако по умолчанию Gradle упаковывает только
          // общие библиотеки в вашем приложении.
          target += listOf("native-lib-demo",
                  // Вам нужно указать этот исполняемый файл и его источники в вашем CMakeLists.txt
                  // с помощью команды add_executable(). Однако создание исполняемых файлов из вашего
                  // собственные исходные коды необязательны, и сборка собственных библиотек для упаковки в них
                  // ваше приложение удовлетворяет большинству требований проекта. 
                  "моя-исполняемая-демо")
        }
      }
    }
    создать("платно") {
      ...
      externalNativeBuild {
        сделай {
          ...
          target += listOf("native-lib-paid",
                  "мой-исполняемый-платный")
        }
      }
    }
  }
  // Используйте этот блок, чтобы связать Gradle с вашим скриптом CMake или ndk-build.
  externalNativeBuild {
    сделать {...}
    // или ndkBuild {...}
  }
}

Чтобы узнать больше о настройке вкусов продукта и вариантов сборки, перейдите на Настроить варианты сборки. Для список переменных, которые вы можете настроить для CMake с помощью arguments свойство, см. Использование переменных CMake.

Включить предварительно созданные собственные библиотеки

Если вы хотите, чтобы Gradle упаковывал предварительно созданные собственные библиотеки, которые не используются ни в внешняя нативная сборка, добавьте их в src/main/jniLibs/ ABI каталог вашего модуля.

Требуются версии подключаемого модуля Android Gradle до 4.0, включая CMake ИМПОРТИРОВАНО цели в вашем каталоге jniLibs , чтобы они были включены в ваш приложение. Если вы переходите с более ранней версии плагина, вы можете столкнуться с ошибкой, подобной следующей:

 * Что пошло не так:
Не удалось выполнить задачу ':app:mergeDebugNativeLibs'.
> Произошел сбой при выполнении com.android.build.gradle.internal.tasks.Workers$ActionFacade
   > Было найдено более одного файла с независимым от ОС путем «lib/x86/libprebuilt.so».

Если вы используете Android Gradle Plugin 4.0, переместите все библиотеки, используемые ИМПОРТИРОВАНО Цели CMake из каталога jniLibs , чтобы избежать этой ошибки.

Укажите ABI

По умолчанию Gradle собирает вашу нативную библиотеку в отдельные . so . файлы для бинарных интерфейсов приложений (ABI) NDK поддерживает и упаковывает их все в ваше приложение. Если ты хочешь Gradle для сборки и упаковки только определенных конфигураций ABI вашего родного библиотеки, вы можете указать их с помощью ndk.abiФильтры флаг в файле build.gradle уровня модуля , как показано ниже:

Groovy 

андроид {
  ...
  defaultConfig {
    ...
    externalNativeBuild {
      сделать {...}
      // или ndkBuild {...}
    }
    // Подобно другим свойствам в блоке  defaultConfig ,
    // вы можете настроить блок ndk для каждого вкуса продукта
    // в вашей конфигурации сборки.
    ндк {
      // Указывает конфигурации ABI вашего родного
      // библиотеки, которые Gradle должен собрать и упаковать вместе с вашим приложением.
      abiFilters 'x86', 'x86_64', 'armeabi', 'armeabi-v7a',
                   'arm64-v8a'
    }
  }
  типы сборки {. ..}
  externalNativeBuild {...}
}

Котлин 

андроид {
  ...
  defaultConfig {
    ...
    externalNativeBuild {
      сделать {...}
      // или ndkBuild {...}
    }
    // Подобно другим свойствам в блоке  defaultConfig ,
    // вы можете настроить блок ndk для каждого вкуса продукта
    // в вашей конфигурации сборки.
    ндк {
      // Указывает конфигурации ABI вашего родного
      // библиотеки, которые Gradle должен собрать и упаковать вместе с вашим приложением.
      abiFilters += listOf("x86", "x86_64", "armeabi", "armeabi-v7a",
                   "arm64-v8a")
    }
  }
  типы сборки {...}
  externalNativeBuild {...}
}

В большинстве случаев достаточно указать abiFilters в ndk блок, как показано выше, потому что он сообщает Gradle о необходимости сборки и упакуйте эти версии ваших собственных библиотек. Однако, если вы хотите управлять тем, что должен построить Gradle, независимо от того, что вы хотите пакет в свое приложение, настройте еще один флаг abiFilters в defaultConfig.externalNativeBuild.cmake блок (или defaultConfig.externalNativeBuild.ndkBuild 9блок 0004). Грейдл создает эти конфигурации ABI, но упаковывает только те, которые вы указали в блок defaultConfig.ndk .

Рекомендуется публиковать с помощью Android App Bundle, чтобы еще больше сократить размер вашего приложения, так как только собственные библиотеки, соответствующие ABI пользовательского устройство будет доставлено вместе с загрузкой.

Для публикации устаревших приложений с использованием APK (созданных до августа 2021 г.) рассмотрите настройка несколько APK на основе ABI — вместо создания одного большого APK со всеми версии ваших нативных библиотек, Gradle создает отдельный APK для каждого ABI вы хотите поддерживать, и упаковывает только те файлы, которые нужны каждому ABI.

No related posts.