Что такое Android Studio

Назад

Android Studio — интегрированная среда разработки производства Google, с помощью которой разработчикам становятся доступны инструменты для создания приложений на платформе Android OS. Android Studio можно установить на Windows, Mac и Linux. Учетная запись разработчика приложений в Google Play App Store стоит $25. Android Studio создавалась на базе IntelliJ IDEA.

IDE можно загрузить и пользоваться бесплатно. В ней присутствуют макеты для создания UI, с чего обычно начинается работа над приложением. В Studio содержатся инструменты для разработки решений для смартфонов и планшетов, а также новые технологические решения для Android TV, Android Wear, Android Auto, Glass и дополнительные контекстуальные модули.

Среда Android Studio предназначена как для небольших команд разработчиков мобильных приложений (даже в количестве одного человека), или же крупных международных организаций с GIT или другими подобными системами управления версиями.

Опытные разработчики смогут выбрать инструменты, которые больше подходят для масштабных проектов. Решения для Android разрабатываются в Android Studio с использованием Java или C++. В основе рабочего процесса Android Studio заложен концепт непрерывной интеграции, позволяющий сразу же обнаруживать имеющиеся проблемы. Продолжительная проверка кода обеспечивает возможность эффективной обратной связи с разработчиками. Такая опция позволяет быстрее опубликовать версию мобильного приложения в Google Play App Store. Для этого присутствует также поддержка инструментов LINT, Pro-Guard и App Signing.

С помощью средств оценки производительности определяется состояние файла с пакетом прикладных программ. Визуализация графики дает возможность узнать, соответствует ли приложение ориентиру Google в 16 миллисекунд. С помощью инструмента для визуализации памяти разработчик узнает, когда его приложение будет использовать слишком много оперативной памяти и когда произойдет «сборка мусора». Инструменты для анализа батареи показывают, какая нагрузка приходится на устройство.

Android Studio совместима с платформой Google App Engine для быстрой интеграции в облаке новых API и функций. В среде разработки вы найдете различные API, такие как Google Play, Android Pay и Health. Присутствует поддержка всех платформ Android, начиная  с Android 1.6. Есть варианты Android, которые существенно отличаются от версии Google Android. Самая популярная из них — это Amazon Fire OS. В Android Studio можно создавать APK для этой ОС. Поддержка Android Studio ограничивается онлайн-форумами.

 

Особенности

Новые функции появляются с каждой новой версией Android Studio. На данный момент доступны следующие функции:

  • Расширенный редактор макетов: WYSIWYG, способность работать с UIкомпонентами при помощи Drag-and-Drop, функция предпросмотра макета на нескольких конфигурациях экрана.
  • Сборка приложений, основанная на Gradle.
  • Различные виды сборок и генерация нескольких .apkфайлов
  • Рефакторинг кода
  • Статический анализатор кода (Lint), позволяющий находить проблемы производительности, несовместимости версий и другое.
  • Встроенный ProGuard и утилита для подписывания приложений.
  • Шаблоны основных макетов и компонентов Android.
  • Поддержка разработки приложений для Android Wearи Android TV.
  • Встроенная поддержка Google Cloud Platform, которая включает в себя интеграцию с сервисами Google Cloud Messagingи App Engine.
  • Android Studio 2.1 поддерживает Android Preview SDK, а это значит, что разработчики смогут начать работу по созданию приложения для новой программной платформы.
  • Новая версия Android Studio 2.1 способна работать с обновленным компилятором Jack, а также получила улучшенную поддержку Java 8 и усовершенствованную функцию Instant Run.
  • Начиная с Platform-tools 23.1.0 для Linux исключительно 64-разрядная.
  • В Android Studio 3.0 будут по стандарту включены инструменты языка Kotlinоснованные на JetBrains IDE.

 

У вас нет прав для комментирования.

Подключаем Git к Android Studio

Статья проплачена кошками — всемирно известными производителями котят.

Если статья вам понравилась, то можете поддержать проект.

Android Studio умеет работать с системами контроля версий (version control system, сокр.VCS). Самой популярной системой является Git, которая стала практически стандартом во многих языках программирования.

Сама по себе Git управляется через командную строку. Для изучения её возможностей есть множество документации. Мы сфокусируемся на подключении Git к проекту в Android Studio.

Чтобы лучше понять объяснения, откройте старый проект Hello Kitty или создайте его заново, если успели его удалить.

Для начала нужно установить Git. Перейдите на страницу загрузки http://git-scm.com/downloads и скачайте последнюю версию под вашу операционную систему.

Запускаем процесс инсталяции. Не рекомендую устанавливать в папку по умолчанию в системной папке Windows C:\Program Files, так как из-за пробела между словами часто возникают проблемы у многих пользователей при работе с командной строкой. Я установил в папке D:\Git. Желательно также прописать путь к папке

D:\Git\bin\ в переменной окружения PATH.

Запускаем файл git-bash.exe для запуска консоли. Следует сконфигурировать Git, указав своё имя и электронный адрес, чтобы можно было установить авторство изменений в коде. Вводим по очереди две команды:


$ git config --global user.name "Alexander Klimoff"
$ git config --global user.email "[email protected]"

Возвращаемся в студию. Выбираем в меню File | Settings и в диалоговом окне в левой части выбираем секцию Version Control | Git. Нажимаем кнопку с многоточием и находим нужный файл на диске.

Для проверки можно щёлкнуть по кнопке

Test, вы должны увидеть радостное сообщение в успешном случае. Закрываем окно настроек, применив изменения.

Данная настройка запоминается и в новых проектах этот шаг можно пропустить.

Далее идём в меню VCS | Import into Version Control | Create Git Repository и в диалоговом окне выбираем корневую папку проекта. Для удобства можно сразу нажать на значок студии (третий слева), чтобы сразу переместиться в корневую папку, если окно откроется с другой папкой.

Нажимаем кнопку OK и создаём локальный Git-репозиторий. Под капотом выполняется команда

git init.

Как только вы это сделаете, в студии произойдут удивительные изменения. Многие имена файлов в левой панели окрасятся в коричневый цвет.

Коричневый цвет шрифта означает, что файл распознан системой контроля версий на локальном компьютере, но ещё не добавлен в репозиторий. Нам следует подсказать системе об этом.

Но не будем торопиться. При создании локального репозитория студия также создала несколько специальных файлов .gitignore, которые помогают системе контроля версий игнорировать некоторые файлы проекта при изменениях. Один такой файл вы можете найти в корневой папке проекта, а второй в папке app. Можете открыть их любым текстовым редактором. Начнём с файла из корневой папки.


. gradle
/local.properties
/.idea/workspace.xml
/.idea/libraries
.DS_Store
/build
/captures

Как видим, Git будет игнорировать файл .idea/workspace.xml, который относится к конфигурации самой студии на вашем компьютере и к самому проекту не имеет отношения. Аналогично будет проигнорирован файл local.properties, который является уникальным для каждого компьютера. Можно указывать не только отдельные файлы, но и папки. Например, в списке присутствует папка /build. В эту папку попадают файлы при компиляции. Их нет смысла отслеживать, так как они постоянно меняются, когда вы запускаете приложение для проверки. Все файлы, которые должны быть проигнорированы, выводятся обычным чёрным цветом. Обратите внимание на имя файла

local.properties на скриншоте выше.

Кроме чёрного и коричневого цвета, имена файлов могут также выводиться синим цветом (файл изменён), зелёным (новый файл).

При подключении Git в нижней части студии появится новая вкладка Version Control. Откройте её. Сейчас вы видите две секции: Default и Unversioned Files. Секция Default сейчас пуста. При изменении или создании новых файлов они попадут в эту секцию. Секция

Unversioned Files содержит файлы, которые ещё не были учтены системой контроля версий.

При создании нового проекта файлы автоматически не учитываются и находятся в секции Unversioned Files. Мы хотим их перенести в репозиторий. В левой части панели находятся две колонки со значками. Найдите значок с изображением папки в скобках (при подведении курсора появится подсказка Group by Directory) и нажмите на неё. Файлы будут сгруппированы, как в проекте. Так проще вам будет понять структуру.

Щёлкаем правой кнопкой мыши на Unversioned Files и выбираем в контекстном меню Add to VCS. Либо можно перетащить мышкой эту секцию на секцию Default. В результате все файлы переместятся и будут учтены системой контроля версий.

После добавления файлов нажмите на значок с зелёной стрелкой вверх и надписью VCS (Commit Changes). Откроется диалоговое окно. В текстовом поле Commit Message введите текст, поясняющий изменения в проекте и нажмите кнопку Commit.

Файлы исчезнут из секции Default и теперь находятся под контролем Git. При изменении файл снова попадёт в данную секцию и вам снова нужно выполнить предыдущую операцию Commit.

Например, откроем файл манифеста и добавим разрешение на работу с интернетом. Файл окрасится в синий цвет. Комментируем изменения в проекте, добавив сообщение Добавлено разрешение на интернет.

Просматривать изменения можно на вкладке Log. Вы можете просматривать коммиты и ветки.

Таким образом мы познакомились с базовыми приёмами работы с Git.

Также вы можете создавать новые ветки, сливать их в одну и выполнять прочие операции.

Естественно, вы можете также выкладывать проект на GitHub или наоборот вносить изменения в локальный проект из удалённого репозитория.

Реклама

Добавьте код C и C++ в свой проект

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

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

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

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

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

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

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

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

Внимание экспериментальных пользователей Gradle: Рассмотрим переход на плагин версии 2.2.0 или выше и использование CMake или ndk-build для создания собственных библиотек, если к вам относится любое из следующих условий: нативный проект уже использует CMake или ndk-build; вы бы предпочли использовать стабильную версия системы сборки Gradle; или вам нужна поддержка дополнительных инструментов, например CCache. В противном случае вы можете продолжать использовать экспериментальная версия Gradle и плагин для Android.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Примечание: Мгновенно Run не совместим с компонентами вашего проекта, написанными на родном языке. код.

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

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

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

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

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

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

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

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

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

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

Codelabs

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

Начало работы с собственными действиями C++ и Android | Патрик Мартин | Разработчики Android

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

Хотя мое внимание сосредоточено на играх, я не буду рассказывать вам, как написать приложение OpenGL или как спроектировать собственный игровой движок. Это дискуссия, которая буквально заполняет книги.

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

Выбрав C++, вы не станете «более родным» для Android, чем при использовании управляемого языка, такого как Kotlin или Java. Вопреки интуиции, вы в некотором роде пишете стороннее приложение, в котором доступно только подмножество функций Android. Для большинства приложений лучше использовать такие языки, как Kotlin.

Есть несколько исключений из этого правила. Близкая и дорогая моему сердцу разработка игр. Поскольку игры обычно используют пользовательскую логику рендеринга, часто написанную на OpenGL или Vulkan, ожидается, что игра будет выглядеть не так, как стандартное приложение для Android. Если вы также учтете, что C и C++ почти универсальны для любой вычислительной платформы, а также относительное богатство библиотек C для поддержки разработки игр, может стать разумным пойти по пути нативной разработки.

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

Я не буду показывать вам, как инициализировать контекст Vulkan или OpenGL. Я рекомендую ознакомиться с примерами, которые предоставляет Google, хотя я дам несколько советов, которые сделают вашу жизнь проще. Вместо этого вы можете использовать библиотеку, такую ​​​​как SDL или даже FPLBase от Google.

Сначала нам нужно убедиться, что у вас установлено все для нативной разработки. Для этого нам понадобится Android NDK. Запустите Android Studio:

И в разделе «Настройка» выберите «Диспетчер SDK»:

Отсюда установите LLDB (собственный отладчик), CMake (систему сборки, которую мы будем использовать) и сам NDK:

Теперь, когда у вас все настроено, мы создадим проект. Мы хотим создать пустой проект без Activity:

NativeActivity был в Android со времен Gingerbread, но я бы рекомендовал выбрать самую высокую цель, доступную вам в то время, если вы только учитесь.

Теперь нам нужно создать CMakeLists.txt, чтобы сообщить Android, как собрать наш проект C++. Щелкните правой кнопкой мыши свое приложение в представлении проекта и создайте новый файл:

Named CMakeLists.txt:

И создайте простой файл CMake:

Мы заявляем, что используем последнюю версию CMake в Android Studio (3.6.0) и что мы создаем общую библиотеку под названием helloworld -с. Я также добавил исходный файл, который мы должны создать.

Почему общая библиотека, а не исполняемый файл? Android использует процесс под названием Zygote для ускорения процесса запуска приложения или службы в среде выполнения Android. Это относится ко всем процессам, с которыми сталкивается пользователь в Android, поэтому первый шанс, что ваше приложение сможет запустить код, будет внутри управляемой виртуальной машины. Затем управляемый код должен загрузить файл общей библиотеки с вашей логикой, которая обрабатывается за вас, если вы используете собственное действие. И наоборот, при создании исполняемого файла ожидается, что операционная система напрямую загрузит вашу программу и выполнит функцию C, называемую «main». это возможно в Android, но я не нашел ему практического применения.

Теперь создадим файл C++:

И переместим его в каталог, который мы указали в make-файле:

И давайте добавим что-то маленькое, что скажет нам, правильно ли он строится:

И, наконец, давайте скомпонуем C++ проект в наше приложение:

Если все пойдет хорошо, проект будет успешно обновлен:

И вы можете запустить сборку без каких-либо проблем:

Что касается того, что изменилось в вашем скрипте сборки. Если вы откроете файл build.gradle вашего приложения, вы должны увидеть это externalNativeBuild запись:

Активность — это в основном окно, которое Android использует для отображения интерфейса вашего приложения. Обычно вы пишете класс на Java или Kotlin, который расширяет Activity, но Google создал специальный эквивалент C, называемый нативным Activity.

Лучший способ создать нативную активность — включить native_app_glue . Многие образцы копируют его из SDK в свой проект. В этом нет ничего плохого, но лично я предпочитаю оставить его на месте и сделать из него библиотеку, от которой зависит моя игра. Я сделаю это СТАТИЧЕСКОЙ библиотекой, чтобы не платить дополнительные затраты на вызовы динамической библиотеки:

Здесь нужно разобрать лот , так что давайте начнем. Сначала я add_library , чтобы создать библиотеку с именем native_app_glue и обозначить ее как STATIC . Затем я ищу автоматически сгенерированную переменную среды ${ANDROID_NDK} , чтобы найти некоторые файлы в установке NDK. Используя это, я вытаскиваю реализацию для native_app_glue: android_native_app_glue.c .

После того, как мой код связан с целью, я хочу сказать, где цель находит свои заголовочные файлы. я использую target_include_directories , чтобы извлечь папку со всеми ее заголовками и обозначить их как заголовки PUBLIC . Другие варианты: ВНУТРЕННИЙ или СОБСТВЕННЫЙ , эти прицелы пока неактуальны. В некоторых учебниках может использоваться include_directories вместо target_include_directories . Это старая практика. Более поздняя версия target_include_directories позволяет связать каталоги с целью, что помогает упростить более крупные проекты.

Теперь я хочу иметь возможность записывать информацию в Android LogCat. Просто запись в стандартный вывод (например: std::cout или printf ) не работает так же хорошо, как в обычных приложениях C и C++. Используя find_library для поиска log , мы кэшируем библиотеку журналов Android, чтобы ссылаться на нее позже.

Наконец, мы говорим CMake сделать helloworld-c зависимым от native_app_glue , android и библиотеки, которую мы назвали log-lib с использованием target_link_libraries . Это позволит нам ссылаться на собственную логику приложения в нашем проекте C++. Вызов set перед add_library также гарантирует, что helloworld-c не реализует функцию ANativeActivity_onCreate, , которая предоставляется android_native_app_glue .

Теперь мы готовы, давайте создадим наше приложение!

Что здесь происходит?

Во-первых, с помощью extern "C"{} мы просто говорим компоновщику, что нам нужно рассматривать все, что находится между этими фигурными скобками, как C. Вы все еще можете писать код C++ внутри них, но функции будут выглядеть так: Функции C для остальной части нашей программы.

Я создаю небольшую функцию-заполнитель handle_cmd . Это будет служить нашим циклом сообщений в будущем. Любые события касания, события окна и т. д. будут проходить здесь.

Мясо программы android_main . Это вызывается android_native_app_glue при запуске вашего приложения. Мы начинаем с указания pApp->onAppCmd ​​ на наш цикл сообщений, чтобы системным сообщениям было куда идти.

Далее используем ALooper_pollAll для обработки всех системных событий, находящихся в очереди, а первый аргумент — тайм-аут. Если мы получаем значение больше или равное 0, нам нужно помочь pSource обработать событие. В противном случае мы продолжаем, пока приложение не закроется.

Мы по-прежнему не можем запустить эту активность, но не стесняйтесь строить, чтобы убедиться, что все в порядке.

Теперь нам нужно заполнить ваш AndroidManifest.xml, чтобы сообщить вашей системе, как запускать ваше приложение. Вы можете найти его в приложении > манифесты > AndroidManfiest.xml:

Сначала мы сообщим Android android о нативной активности (называемой «android.app.NativeActivity») и скажем ему не уничтожать активность при изменении ориентации или состояния клавиатуры:

Затем мы сообщаем нативной активности, где ее найти код, который мы хотим запустить. Если вы забыли имя, проверьте свой CMakeLists.txt!

И мы сообщаем операционной системе Android, что это активность лаунчера и основная активность:

Если все пойдет хорошо, вы можете нажать отладку и увидеть пустое окно!

В репозитории образцов Google уже есть отличные образцы OpenGL:

Образцы Android NDK с Android Studio. Внесите свой вклад в разработку googlesamples/android-ndk, создав учетную запись на…

github.com

Я дам вам несколько полезных советов, чтобы начать работу. Во-первых, чтобы использовать OpenGL, добавьте следующие строки в свой CMakeLists.txt:

. Здесь вы можете сделать гораздо больше интеллекта для различных платформ Android, но добавление EGL и GLESv3 к вашей цели будет хорошо для последних версий Android.

Затем я хотел бы создать класс с именем Renderer для обработки моего рендеринга. Если вы создаете приложение с конструктором для инициализации вашего рендерера, деструктором для его уничтожения и функцией render() для рендеринга, я бы предложил сделать ваше приложение таким:

Итак, первое, что я сделал начать использовать это маленькое поле в android_app под названием userData . Вы можете хранить здесь все, что хотите, и каждый экземпляр этого android_app поймет. Я решил добавить свой рендерер.

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

Наконец, если есть рендерер (т.е. окно было создано), я получаю его из android_app и прошу его рендерить. В противном случае я просто продолжаю обрабатывать этот цикл.

Теперь вы готовы использовать OpenGL ES 3, как если бы вы работали на любой другой платформе! Вот несколько полезных ссылок, если вам нужны дополнительные ресурсы или руководства:

  • Образцы Google Android NDK были неоценимы для меня, чтобы собрать воедино это руководство: https://github.com/googlesamples/android-ndk/
  • Для нативной активности: https://github.com/googlesamples/android -ndk/tree/master/native-activity
  • CMake — моя предпочтительная система сборки на Android для C++, вы можете найти справочные страницы здесь: https://cmake.

    No related posts.