Как повысить целевой уровень api
Уровень API игры на Unity3d для публикации в Google Play (error API level 29)
При публикации приложения в Google Play у вас может появится ошибка связанная с используемым им уровнем API:
«You uploaded a debuggable APK or Android App Bundle. For security reasons you need to disable debugging before it can be published in Google Play. Learn more about debuggable APKs or Android App Bundles. You App currently targets API livel 28 and must target at least API level 29 to ensure it is built on the latest APIs optimized for security and perfomance. Change your app’s target API level to at least 29.»
«Вы загрузили отлаживаемый APK или Android App Bundle. По соображениям безопасности вам необходимо отключить отладку, прежде чем ее можно будет опубликовать в Google Play. Узнайте больше об отлаживаемых APK-файлах или наборах Android-приложений. Ваше приложение в настоящее время нацелено на API livel 28 и должно быть ориентировано как минимум на уровень API 29, чтобы гарантировать, что оно построено на последних API, оптимизированных для обеспечения безопасности и производительности. Измените целевой уровень API вашего приложения как минимум на 29.»
На момент написания этого поста Google Play требует для всех новых игр целевой уровень API равный 29 или выше. Эта настройка находится (в Unity3d) в «File» — «Build Settings» — «Player Settings» — «Player» — «Android» — «Other Settings» — «Target API Level».
Если после смены целевого уровня API приложение успешно собралось, то проблема решена. Google Play примет эту версию. В моём же случае все оказалось немного сложнее. В установленном Unity3D не оказалось требуемой версии Android SDK и его пришлось скачивать отдельно.
Через функцию «Update Android SDK» внутри Unity3d обновление не устанавливалось. Обновить Android SDK мне помог старый-добрый Android Studio. После загрузки и установки Adnroid Studio зайдите в «File» — «Settings» — «Appearance & Behavior» — «System Settings» — «Android SDK».
В этом окне настроек необходимо скачать недостающие версии — это делается путем установки флажка напротив желаемой версии и нажатии кнопки «Apply». Далее откройте в проводнике директорию с расположением всех версий SDK («Android SDK Location») и скопируйте нужную версию в директорию которую использует Unity3d для своей работы. Путь к этой директории находится в редакторе Unity3d — «Edit» — «Preferences» — «External Tools» — «Android SDK Tools».
После копирования требуемой версии Android SDK приложение будет собираться без проблем и Google Play его одобрит.
Уровень Android API, обратная и прямая совместимость
Добрый вечер, друзья. Мы подготовили полезный перевод для будущих студентов курса «Android-разработчик. Продвинутый курс». С радостью делимся с вами данным материалом.
Если вы читаете эту статью, значит вас могут интересовать такие вещи, как:
Все эти понятия связаны друг с другом, и я постараюсь объяснить их вам в этой статье простым, но эффективным способом.
Для этого необходимо понимать разницу между SDK и API и знать что такое уровень API в экосистеме Android.
Это правда, что в Android между SDK и API существует отношение 1:1, и часто эти два термина используются как синонимы, но важно понимать, что это не одно и то же.
Правильнее говорить, что для каждой версии Android есть SDK и эквивалентный API, а также уровень этого API.
Расшифровывается как Software Development Kit (комплект для разработки программного обеспечения). Обратите внимание на слово «kit» (комплект)… он как раз представляет из себя набор различных инструментов, библиотек, документации, примеров, помогающих разработчикам создавать, отлаживать и запускать приложения для Android. API предоставляется вместе с SDK.
Если открыть SDK Manager в Android Studio, можно будет яснее увидеть, из чего состоит Android SDK.
На первой вкладке SDK Platform перечислены SDK каждой версии Android.
Как показано на рисунке ниже, Android 9.0 SDK (также известный как Pie) содержит:
На второй вкладке SDK Tools показаны другие инструменты, которые также являются частью SDK, но не зависят от версии платформы. Это означает, что они могут быть выпущены или обновлены отдельно.
Расшифровывается как Application Programming Interface (программный интерфейс приложения). Это просто интерфейс, уровень абстракции, который обеспечивает связь между двумя разными «частями» программного обеспечения. Он работает как договор между поставщиком (например, библиотекой) и потребителем (например, приложением).
Это набор формальных определений, таких как классы, методы, функции, модули, константы, которые могут использоваться другими разработчиками для написания своего кода. При этом API не включает в себя реализацию.
Уровень API
Уровень API — это целочисленное значение, однозначно идентифицирующее версию API фреймворка, предлагаемую платформой Android.
Обычно обновления API фреймворка платформы разрабатываются таким образом, чтобы новая версия API оставалась совместимой с более ранними версиями, поэтому большинство изменений в новом API являются аддитивными, а старые части API становятся устаревшими, но не удаляются.
И теперь кто-то может задаться вопросом…
если API Android не предоставляет реализацию, а SDK Manager предлагает необязательный загружаемый исходный код API в составе SDK, то где находится соответствующая реализация?
Ответ прост. На устройстве.
Давайте разберемся с этим…
От исходного кода к APK-файлу
Как правило, проект под Android состоит из кода, написанного разработчиками с использованием Android API (модуль приложения), а также некоторых других библиотек/зависимостей (.jar-файлов, AAR, модулей и т.д.) и ресурсов.
Процесс компиляции преобразует код, написанный на Java или Kotlin, включая зависимости (одна из причин уменьшить ваш код!), в байт-код DEX, а затем сжимает все в файл APK вместе с ресурсами. На данном этапе реализация API не включена в итоговый APK!
Процесс сборки — Android Developers
DEX файлы и Android Runtime
Архитектура Android — Android Developers
Android Runtime — это место, где делается вся грязная работа и где выполняются DEX-файлы. Оно состоит из двух основных компонентов:
Версия API, доступная на этом уровне, соответствует версии платформы Android, на которой запущено приложение.
Например, если на фактическом устройстве установлен Android 9 (Pie), доступны все API до 28 уровня.
compileSdkVersion
Настоятельно рекомендуется выполнить компиляцию с последней версией SDK:
Это же приложение может работать на устройстве с Android 9 Pie (API 28 уровня), поскольку метод API xyz() все еще доступен на API 28 уровня.
minSdkVersion
Это значение обозначает минимальный уровень API, на котором приложение может работать. Это минимальное требование. Если не указан, значением по умолчанию является 1.
Разработчики обязаны установить корректное значение и обеспечить правильную работу приложения до этого уровня API. Это называется обратной совместимостью.
Чтобы обеспечить обратную совместимость, разработчики могут во время выполнения проверять версию платформы и использовать новый API в более новых версиях платформы и старый API в более старых версиях или, в зависимости от случая, использовать некоторые статические библиотеки, которые обеспечивают обратную совместимость.
Также важно упомянуть, что Google Play Store использует это значение, чтобы определить, можно ли установить приложение на определенное устройство, сопоставив версию платформы устройства с minSdkVersion приложения.
Разработчики должны быть очень осторожны при выборе этого значения, поскольку обратная совместимость не гарантируется платформой.
Выбор «правильного» значения для проекта также является бизнес-решением, поскольку оно влияет на то, насколько большой будет аудитория приложения. Посмотрите на распределение платформ.
targetSdkVersion
Это значение указывает уровень API, на котором приложение было разработано.
Иногда могут быть некоторые изменения API в базовой системе, которые могут повлиять на поведение приложения при работе в новой среде выполнения.
Целевой уровень приложения включает поведение среды выполнения, которое зависит от конкретной версии платформы. Если приложение не готово к поддержке этих изменений поведения среды выполнения, оно, вероятно, завершится сбоем.
Простым примером является Runtime Permission, которое было представлено в Android 6 Marshmallow (API 23 уровня).
Приложение может быть скомпилировано с использованием API 23 уровня, но иметь целевым API 22 уровня, если оно еще не готово поддержать новую модель разрешений времени выполнения.
Таким образом, приложение может по-прежнему быть совместимым без включения нового поведения среды выполнения.
В любом случае, как уже упоминалось, Google требует, чтобы приложения удовлетворяли новым требованиям целевого уровня API, поэтому всегда следует иметь высокий приоритет для обновления этого значения.
Теперь соединяя все это вместе, мы видим четкое отношение
minSdkVersion ≤ targetSdkVersion ≤ compileSdkVersion
Имейте в виду, что настоятельно рекомендуется выполнить компиляцию в соответствии с последним уровнем API и стараться использовать targetSdkVersion == compileSdkVersion.
Как успешно повысить целевой уровень API
Нужно ли вносить изменения в другие библиотеки
2 ответа
Версия 28.0.0 является окончательной версией библиотеки поддержки, Чтобы продолжить использовать библиотеки поддержки после обновления до API 29, вам необходимо перейти на AndroidX.
При обновлении также следует проверить, были ли соответствующие изменения в Android 9 Это нужно учитывать.
В вашем случае вы не можете обновить targetSdkVersion без обновления зависимостей.
Изменение его в структуре проекта не сделало бы никакой магии для вас, вы все равно должны следовать тому же процессу, что и при изменении файла Gradle.
Я, однако, боюсь последствий, которые это может оказать на другие библиотеки.
Также обновляйте сторонние библиотеки, так как использование более новых версий библиотек в старых SDK, скорее всего, вызовет проблемы, так как более новые Android SDK имеют изменения в поведении.
Вот несколько личных советов по миграции, не перегруженной тем, что может сломаться:
1. Увеличивайте целевой API каждый раз на 1, а затем полностью тестируйте его
Например, обновите API до 27 с 26, протестируйте, а затем обновите до 28 и т. Д. Причина этого заключается в том, чтобы сузить и учесть изменения поведения в каждом API, начиная с предыдущего целевого API. Мало того, что это будет менее подавляющим, было бы легче найти решения проблем, которые могут возникнуть впоследствии. Если вы перейдете на 29 из 26 напрямую, будет очень трудно определить проблему.
2. Прочтите руководства по миграции для каждого Android SDK
Эти страницы действительно помогли определить устаревшие классы / функции, используемые даже сторонними библиотеками:
Руководство по миграции на Android 8.0
Руководство по миграции на Android 9.0
Делаем новую версию API. Быстро и легко
Коммуникация правит миром. Взаимодействие необходимо и между людьми, и между программным обеспечением. Хотите адекватного ответа на ваш запрос к приложению? API вам в помощь! Необходимость в реализации API возникает практически во всех проектах, и со временем мы задумываемся, можно ли улучшить текущий API? Последовательность конкретных шагов и реальные примеры – наш рецепт создания рабочего web-API проекта.
Первый вопрос, который нужно задать: «А точно ли стоит реализовать новую версию API?» Возможно, уже работающая версия отвечает всем необходимым вам критериям. Но если вы уже для себя ответили «да» на поставленный вопрос, то читайте дальше и найдете наш ответ. Если вы ответили «нет», то тоже читайте дальше и применяйте наш опыт проектирования и реализации в следующих ваших проектах.
Итак, какие же задачи могут стать поводом к разработке новой реализации API. В рамках развития программных продуктов, например, в сфере комплексной безопасности, как у нас, периодически появляется необходимость ускорить процесс клиентской и серверной̆ разработки, или снизить временные затраты на поддержку и развитие API, или упростить поддержку обратной совместимости с помощью версионности API, а также добавить автогенерацию документации API. Или все эти задачи одновременно.
Какие шаги можно предпринять для решения этих задач, и как выйти на новый уровень зрелости API можно узнать в этой статье. Реальный алгоритм действий при разработке новой реализации API, описанный здесь, поможет в создании собственного проекта, а возможно станет предметом дискуссии. Комментарии профессионалов приветствуются!
Рассмотрим на примере API для работы с котиками то, как мы совершенствовали один из наших проектов.
Как понять, что стоит реализовать новую версию API
Для того чтобы понять, что API пора спасать, необходимо пройтись по следующим пунктам:
определить уровень зрелости API;
проверить, есть ли у API версионность;
проверить наличие документации API.
Разберем каждый пункт по отдельности, чтобы точно определиться, стоит ли «игра свеч» или «и так сойдет».
Определим уровень зрелости API
Для этого идеально подходит модель Леонарда Ричардсона, в которой он выделяет четыре уровня зрелости API:
Уровень 0: Один URI и один HTTP метод (в основном метод POST);
Уровень 1: Несколько URI и один HTTP метод;
Уровень 2: Несколько URI, каждый из которых поддерживает разные HTTP методы;
Уровень 3: HATEOAS. Ресурсы сами описывают свои возможности и взаимосвязи.
Если API соответствует 0 или 1 уровню зрелости, то определенно есть куда расти, потому что:
Если используется один URI, то не понятно с каким ресурсом работаем;
Не понятно, что делаем с ресурсом, так как используется один HTTP метод;
Использование одного URI создает трудности с документацией̆ API;
Использование одного URI создает трудности с логированием входящих запросов;
Из-за использования одного URI, информация о типе ресурса передается в теле запроса.
Посчитаем, сколько «если» у нас получилось, и определим направление разработки. Это поможет сконцентрироваться на задачах и четко сформулировать дальнейшие шаги.
Проверим, есть ли у API версионность
Затем необходимо проверить версионность. Это позволит реализовывать изменения в текущем API, а при необходимости даст возможность включать расширения в новую версию API. Кроме того, она позволит серверу облегчить обеспечение обратной совместимости.
Благодаря версионности можно также ранжировать документацию по версиям, чтобы разработчики клиента всегда могли определить, насколько у них актуальная документация. Согласитесь, это удобно разработчикам, тестировщикам и сотрудникам технической поддержки.
Рассмотрим 3 основных способа версионирования API и разберем подробнее каждый из них. Современные разработчики выделяют следующие способы:
Использование разных URI (Uniform Resource Identifier);
Использование параметра запроса;
Использование заголовка, Accept Header/Media Type.
Каждый из приведенных способов версионирования имеет свои плюсы и минусы. И для каждого конкретного случая реализации API необходимо оценить и выбрать оптимальный способ или их комбинацию.
Использование разных URI простой в проектировании, реализации и документировании способ версионирования. Однако он имеет целый ряд недостатков:
приводит к загрязнению URI, так как префиксы и суффиксы добавляются к основным строкам URI;
разбивает существующие URI, то есть все клиенты должны обновиться до нового;
приводит к увеличению размер HTTP кэша для хранения нескольких версий;
создает большое количество дубликатов URI, может снизить производительность приложения из-за увеличения количества обращений к кэшу;
является крайне негибким и не позволяет просто изменить ресурс или небольшой их набор.
Пример:
2. Использование параметра запроса позволяет легко документировать версионность и рекомендуется к использованию в случае, если важно HTTP – кэширование. Однако и этот способ приводит к загрязнению пространства URI.
Пример:
3. Использование заголовка и Accept Header/Media Type также легко документировать и, в отличие от предыдущих способов не приводит к загрязнению пространства URI. Но и у этого способа выделяют несколько минусов:
приводит к неправильному использованию заголовков, так как они изначально предусматривались не для версионирования;
требует для управления версиями на основе заголовка и типа медиа использования таких инструментов, как Postman, или создания автоматизированных средств, добавляющих необходимый̆ заголовок в HTTP запрос.
Пример:
Выбор конкретного способа целиком лежит на плечах разработчика, исходя из поставленной задачи и навыков. Каждый вариант вполне рабочий, но имеет свою специфику и особенности реализации.
Проверим наличие документации API
Даже к фену удобно иметь описание, не говоря уже о серьезной проекте разработки ПО. Поэтому наглядное описание API всегда удобно для использования как backend, так и frontend разработчиками. Документация может быть реализована, например, с помощью Swagger (фреймворк для спецификации RESTful API), он дает возможность не только интерактивно просматривать спецификацию, но и отправлять запросы с помощью Swagger UI:
Немного окунувшись в теорию и предварительный анализ, переходим непосредственно к проектированию и реализации API. Наше API отвечал следующим критериям:
соответствует 0 уровню зрелости (Один URI и один HTTP метод);
невозможно достоверно установить, с каким ресурсом API работает и какие функции выполняет;
отсутствуют автоматизированные средства документации API, что приводит к неполной документации API или ее полному отсутствию для некоторых запросов;
появляются сложности с поддержкой обратной совместимости, так как нет версионности API.
Для большего понимания того, что не нравилось, приведем пример того, как выглядел наш API.
Пример:
Цели реализации нового API
Если в предыдущем пункте мы уверенно выявили хотя бы один пункт в существующем API, то самое время переходить к реализации нового. Основными целями, которые преследует разработчики при создании API являются:
Ускорение процесса клиентской и серверной̆ разработки;
Снижение временных затрат на поддержку и развитие API;
Добавление автогенерации документации API;
Поддержка версионности API для упрощения поддержки обратной совместимости с помощью версионности API.
Таким образом, проект получает автономность от его создателя, гибкость в масштабировании и апгрейде и, зачастую, серьезно выигрывает по производительности в целом.
Повышаем уровень зрелости API
Для решения вышеперечисленных проблем и достижения целей было принято решение о переходе на 2 уровень зрелости API. Это позволило понять, с каким ресурсом идет текущая работа и что с ним необходимо сделать, плюс появилась возможность документировать API.
Для того, чтобы повысить API с 0 на 2 уровень зрелости были проанализированы все текущие проблемы и выделены следующие пункты:
1. Разделение текущего API на смысловые части для выделения соответствующего ресурса для каждой части;
2. Использование методов, соответствующих действиям над ресурсами: GET, POST, PUT, DELETE;
3. Обозначение ресурса во множественном числе;
Пример:
4. Указание фильтрации в параметрах.
Пример:
Добавляем версионность
После повышения зрелости API выходим на новый этап и выбираем способ версионирования. Для текущего проекта был выбран способ версионирования с использованием собственного заголовка. Это решение не попадает в пункт “неправильное использование заголовков”, так как будет использоваться собственный заголовок. Для удобства было решено указывать версии вида “2.n”.
Для начала реализуем контроллер:
После этого для реализации версионности, создадим enum:
Если в заголовке было отправлено значение “2.0”, до контроллера оно дойдет уже в виде “v2”. При такой реализации вместо того, чтобы перечислять все доступные версии, можно будет указать в заголовке, что ожидается enum. А контроллер после добавления версионирования будет выглядеть так:
При дальнейшем развитии API и реализации новых версий, список всех существующих версий будет храниться в enum. Когда для конкретной̆ новой̆ версии потребуется уникальная реализация, то в контроллере можно будет указать версию явно.
Указание версии было решено сделать обязательным.
Документируем
И наконец переходим к документированию. Критерии выбора конкретного инструмента были основаны на собственном опыте и дискуссии с коллегами-разработчиками. В ходе обсуждения был выбран популярный и широко используемый инструмент автогенерации API Swagger. Он не является единственным для решения задач документирования, но в нашем случае был признан оптимальным, так как бесплатен, прост для освоения и обладает необходимым набором функций для грамотного документирования API.
Рассмотрим пример реализации документации для созданного выше контроллера. Для этого реализуем интерфейс:
С его помощью можно добавить название и описание API текущего контроллера, описание каждого запроса, плюс есть возможность указать схему тела запроса. Остальную информацию Swagger получает из аннотаций контроллера.
Перейдя в Swagger UI увидим задокументированное API:
Получим более подробную информацию:
Преимущества новой версии API
На примерах выше был продемонстрирован переход с 0 уровня зрелости API на 2 уровень зрелости согласно модели Ричардсона, благодаря этому мы получили:
повышение уровня зрелости API, что дало понимание, с каким ресурсом мы работаем и что с ним делаем;
версионирование, которое позволит вносить изменения в текущий API;
удобное документирование и появление внятной документации, да и документации вообще.
В итоге и на стороне сервера, и на стороне клиента теперь можно увидеть актуальный API с полным описанием методов, моделей, кодов ответов, параметров запроса и версий. Это значительно упростит разработку новых версий в будущим и сэкономит время на разбор чужого кода.
Скорость разработки при переходе на новую версию API значительно возросла, ведь разработчикам стало значительно удобнее и приятнее работать. Наш путь разработки оказался вполне рабочим и его смело можно рекомендовать для применения в реальных проектах. А может в вашем арсенале есть другие варианты? Готовы обсудить!