Gradle android library manifest

Содержание
  1. Manifest Merging
  2. In this document
  3. See also
  4. Merge Conflict Rules
  5. Merge Conflict Markers and Selectors
  6. Merge Conflict Markers
  7. Marker attributes
  8. Merge conflict marker for imported libraries
  9. Marker Selectors
  10. Injecting Build Values into a Manifest
  11. Manifest Merging Across Product Flavor Groups
  12. Implicit Permissions
  13. Handling Manifest Merge Build Errors
  14. Советы по работе с Gradle для Android-разработчиков
  15. Небольшой оффтоп для тех, кому совсем ничего не понятно в Gradle-скриптах
  16. #1 Не редактируйте Gradle-скрипты через IDE
  17. #2 Обращайте внимание на соглашение по именованию модулей
  18. #3 Что выбрать: Kotlin vs Groovy
  19. #4 Как прописывать зависимости в многомодульных проектах
  20. Java platform plugin
  21. Описание зависимостей в extra properties
  22. Описание зависимостей в скриптовом плагине
  23. Описание зависимостей в buildSrc
  24. Композитные сборки
  25. #5 Как обновлять зависимости
  26. #6 Старайтесь не использовать feature-флаги в build config
  27. #7 Несколько слов про базовую структуру проекта
  28. #8 Не забывайте про matchingFallbacks
  29. #9 Убирайте ненужные build variant
  30. #10 В некоторых модулях, завязанных на Android Framework, можно не использовать Android Gradle Plugin
  31. #11 Как написать Gradle-плагин для CI на примере gitlab
  32. Шаг 1: в настройках проекта на gitlab создать переменные окружения
  33. Шаг 2: создать композитную сборку
  34. Шаг 3: написать плагин
  35. Шаг 4: подключить плагин
  36. В заключение
  37. Что ещё посмотреть

Manifest Merging

In this document

See also

With Android Studio and Gradle-based builds, each app can contain manifest files in multiple locations, such as the src/main/ folder for the productFlavor , libraries, Android ARchive (AAR) bundles of Android Library projects, and dependencies. During the build process, manifest merging combines the settings from the various AndroidManifest.xml files included in your app into a single, generated APK manifest file for app packaging and distribution. Manifest settings are merged based on the manifest priority, determined by the manifest’s file location. Building your app merges the manifest elements, attributes, and sub-elements from these manifests for the specified build variant.

Merge Conflict Rules

Merge conflicts occur when merged manifests contain the same manifest element but with a different attribute value that does not resolve based on the default merge conflict rules. Conflict markers and selectors can also define custom merge rules, such as allowing an imported library to have a minSdkVersion higher than the version defined in the other higher priority manifests.

The manifest merge priority determines which manifest settings are retained in merge conflicts, with the settings in higher priority manifest overwriting those in lower priority manifests. The following list details which manifest settings are are the highest priority during the merge process:

  • Highest priority: buildType manifest settings
  • Higher priority: productFlavor manifest settings
  • Medium priority: Manifests in the src/main/ directory of an app project
  • Low priority: Dependency and library manifest settings

Manifest merge conflicts are resolved at the XML node and attribute levels based on the following merge rules.

High Priority Element Low Priority Element Manifest Merge Result
no attribute no attribute no attribute
attribute set to default default attribute
attribute set to non-default low priority attribute
attribute set to default no attribute default attribute
attribute set to non-default high priority attribute
attribute set to default attribute set to default default attribute
attribute set to default attribute set to non-default low priority attribute
attribute set to non-default attribute set to default high priority attribute
attribute set to non-default attribute set to non-default Merge if settings match, otherwise causes conflict error.

Exceptions to the manifest merge rules:

  • The uses-feature android:required; and uses-library android:required elements default to true and use an OR merge so that any required feature or library is included in the generated APK.
  • If not declared, the elements, minSdkVersion and targetSdkVersion , default to a value of 1. When merge conflicts occur, the value in the higher priority manifest version is used.
  • Importing a library with a minSdkVersion value higher than the app’s src/main/ manifest manifest generates an error unless the overrideLibrary conflict marker is used.

Note: If not explicitly declared, the targetSdkVersion defaults to the minSdkVersion value. When no element is present in any manifest or the build.gradle file, the minSdkVersion defaults to 1.

  • When importing a library with a targetSdkVersion value lower than the app’s src/main/ manifest, the manifest merge process explicitly grants permissions and ensures that the imported library functions properly.
  • The manifest element only merges with child manifest elements.
  • The intent-filter element is never changed and is always added to the common parent node in the merged manifest.
  • Important: After the manifests are merged, the build process overrides the final manifest settings with any settings that are also in the build.gradle file. For more details, see Configuring Gradle Builds.

    Merge Conflict Markers and Selectors

    Manifest markers and selectors override the default merge rules through specific conflict resolutions. For example, use a conflict marker to merge a library manifest with a higher minSdkVersion value than the higher priority manifest, or to merge manifests with the same activity but different android:theme values.

    Merge Conflict Markers

    A merge conflict marker is a special attribute in the Android tools namespace that defines a specific merge conflict resolution. Create a conflict marker to avoid a merge conflict error for conflicts not resolved by the default merge rules. Supported merge conflict markers include:

    merge Merges attributes when there are no conflicts with the merge rules. The default merge action. replace Replaces attributes in the lower priority manifest with those from the higher priority manifest. strict Sets the merge policy level so that merged elements with same attributes, but different values generate a build failure, unless resolved through the conflict rules. merge-only Allows merge actions for only lower priority attributes. remove Removes the specified lower priority element from the merged manifest. remove-All Removes all lower priority elements of the same node type from the merged manifest.

    By default, the manifest merge process applies the merge conflict marker to the node level. All declared manifest attributes default to a strict merging policy.

    To set a merge conflict marker, first declare the namespace in the AndroidManifest.xml file. Then, enter the merge conflict marker in the manifest to specify a custom merge conflict action. This example inserts the replace marker to set a replace action to resolve conflicts between the android:icon and android:label manifest elements.

    Marker attributes

    Conflict markers use tools:node and tools:attr attributes to restrict merge actions at the XML node or attribute level.

    The tools:attr markers use only the restrict , remove , and replace merge actions. Multiple tools:attr marker values can be applied to a specific element. For example, use tools:replace=»icon, label, theme» to replace lower priority icon , label , and theme attributes.

    Merge conflict marker for imported libraries

    The overrideLibrary conflict marker applies to the manifest declaration and is used to import a library even though the library’s values, such as minSdkVersion are set to different values than those in the other higher priority manifests.

    Читайте также:  Бесит андроид после ios

    Without this marker, library manifest merge conflicts from the values cause the merge process to fail.

    This example applies the overrideLibrary conflict marker to resolve the merge conflict between minSdkVersion values in the src/main/ manifest and an imported library manifest.

    Note: The default merge process does not allow importing a library with a higher minSdkVersion than the app’s src/main/ manifest unless the overrideLibrary conflict marker is used.

    Marker Selectors

    Marker selectors limit a merge action to a specific lower priority manifest. For example, a marker selector can be used to remove a permission from only one library, while allowing the same permission from other libraries.

    This example uses the tools:node marker to remove the permisionOne attribute, while the tools:selector selector specifies the specific library as com.example.lib1. The permisionOne permission is filtered from only the lib1 library manifests.

    Injecting Build Values into a Manifest

    Manifest merging can also be configured to use manifest placeholders to inject property values from the build.gradle file into the manifest attributes.

    Manifest placeholders use the syntax $ for attribute values, where name is the injected build.gradle property. The build.gradle file uses the manifestPlaceholders property to define the placeholder values.

    Note: Unresolved placeholder names in apps cause build failures. Unresolved placeholder names in libraries generate warnings and need to be resolved when importing the library into an app.

    This example shows the manifest placeholder $ used to inject the build.gradle applicationId property value in to android:name attribute value.

    Note: Android Studio provides a default $ placeholder for the build.gradle applicationId value that is not shown in the build file.

    Gradle build file:

    Merged manifest value:

    The manifest placeholder syntax and build file manifestPlaceholders property can be used to inject other manifest values. For properties other than the applicationId , the manifestPlaceholders property is explicitly declared in the build.gradle file. This example shows the manifest placeholder for injecting activityLabel values.

    Gradle build file:

    Placeholder in the manifest file:

    Note: The placeholder value supports partial value injection, for example android:authority=»com.acme.$.foo» .

    Manifest Merging Across Product Flavor Groups

    When using the GroupableProductFlavor property, the manifest merge priority of any manifests in the product flavor groups follows the order in which the product flavor groups are listed in the build file. The manifest merge process creates a single merged manifest for the product flavor groups based on the configured build variant.

    For example, if a build variant references the product flavors x86 , mdpi , 21 , and paid from the respective product flavor groups ABI , Density , API , and Prod , listed in this order in the build.gradle file, then the manifest merge process merges the manifests in this priority order, which follows how the product flavors are listed in the build file.

    To illustrate this example, the following table shows how the product flavors are listed for each product flavor group. This combination of product flavors and groups defines the build variant.

    Product Flavor Group Product Flavor
    ABI x86
    density mdpi
    API 22
    prod paid

    Manifest merge order:

    • prod-paid AndroidManifest.xml (lowest priority) merges into API-22 AndroidManifest.xml
    • API-22 AndroidManifest.xml merges into density-mpi AndroidManifest.xml
    • density-mpi AndroidManifest.xml merges into ABI-x86 AndroidManifest.xml (highest priority)

    Implicit Permissions

    Importing a library that targets an Android runtime with implicitly granted permissions may automatically add the permissions to the resulting merged manifest. For example, if an application with a targetSdkVersion of 16 imports a library with a targetSdkVersion of 2, Android Studio adds the WRITE_EXTERNAL_STORAGE permission to ensure permission compatibility across the SDK versions.

    Note: More recent Android releases replace implicit permissions with permission declarations.

    This table lists the importing library versions and the declared permissions.

    Importing this library version Declares this permission in the manifest
    targetSdkVersion WRITE_EXTERNAL_STORAGE
    targetSdkVersion WRITE_EXTERNAL_STORAGE , READ_PHONE_STATE
    Declared WRITE_EXTERNAL_STORAGE READ_EXTERNAL_STORAGE
    targetSdkVersion READ_CONTACTS permission READ_CALL_LOG
    targetSdkVersion WRITE_CONTACTS permission WRITE_CALL_LOG

    Handling Manifest Merge Build Errors

    During the build process, the manifest merge process stores a record of each merge transaction in the manifest-merger-

    -report.txt file in the module build/outputs/logs folder. A different log file is generated for each of the module’s build variants.

    When a manifest merge build error occurs, the merge process records the error message describing the merge conflict in the log file. For example, the android:screenOrientation merge conflict between the following manifests causes a build error.

    Источник

    Советы по работе с Gradle для Android-разработчиков

    Всем привет! Я пишу приложения под Android, в мире которого система сборки Gradle является стандартом де-факто. Я решил поделиться некоторыми советами по работе с системой с теми, у кого нет чёткого понимания, как правильно структурировать свои проекты и писать build-скрипты.

    Часто разработчики используют Gradle по наитию и не изучают целенаправленно, потому что не всегда хватает ресурсов на инфраструктурные задачи. А если возникают какие-либо проблемы, то просто копируют готовые куски build-скриптов из ответов на Stack Overflow. Во многом проблема кроется в сложности и чрезмерной гибкости Gradle, а также в отсутствии описания лучших практик в официальной документации.

    Поработав больше пяти лет на аутсорсе, я видел много проектов разной сложности. И на всех этих проектах build-скрипты писались по-разному, где-то встречались не очень удачные решения. Я провел небольшую ретроспективу и резюмировал свой опыт в виде разных советов по использованию Gradle и рассказал их на одном из наших внутренних митапов. В статье я перевел эти советы в текст.

    Небольшой оффтоп для тех, кому совсем ничего не понятно в Gradle-скриптах

    Я заметил, что в Android-сообществе встречаются люди, которые могут годами разрабатывать приложения, но при этом не понимать, как работает Gradle. И достаточно продолжительное время и я был одним из них. Но однажды всё же решил, что гораздо проще потратить время на системное изучение Gradle, чем постоянно натыкаться на непонятные проблемы.

    А так как лучший способ изучить что-то — это попытаться рассказать об этом другим людям, то я подготовил рассказ об основах использования Gradle в контексте Android-разработки специально для тех, кто совсем не разбирается в теме. Так что, возможно, этот митап вам поможет.

    #1 Не редактируйте Gradle-скрипты через IDE

    Android studio умеет генерировать стартовый проект с базовой структурой и готовыми build-скриптами, а также удалять и добавлять модули в существующем проекте. А при редактировании Gradle-скриптов IDE нам заботливо подсказывает, что можно вносить изменения в скрипты через графический интерфейс в меню «File -> Project structure. «. И в начале своей карьеры я вполне успешно пользовался этим инструментом. Но у него есть существенный недостаток: IDE не запускает честную фазу конфигурации Gradle и не смотрит на то, что формируется в памяти при сборке, а всего лишь пытается как-то парсить build-скрипты. Зачастую этот инструмент не распознает то, что было написано вручную, что, на мой взгляд, перечеркивает его пользу.

    Мой совет: лучше не редактировать скрипты через IDE, а использовать редактор кода.

    #2 Обращайте внимание на соглашение по именованию модулей

    В Gradle имя проекта (модуля) берется из соответствующего поля name в объекте Project или названия директории, в которой он лежит. В своей практике я видел разные стили именования модулей, например, в camel- или snake- кейсе: MyAwesomeModule , my_awesome_module . Но есть ли какие-то устоявшиеся соглашения об именах модулей? Кажется, официальная документация Gradle ничего нам об этом не говорит. Но нужно принять во внимание тот факт, что проекты Gradle при публикации в Maven будут соответствовать один к одному модулям Maven. И у Maven есть соглашение, что слова в названиях модулей должны разделяться через символ — . То есть правильнее будет такое название модуля: my-awesome-module .

    #3 Что выбрать: Kotlin vs Groovy

    Изначально в Gradle для DSL использовался язык Groovy, но впоследствии была добавлена возможность писать build-скрипты на Kotlin. Возникает вопрос: что же сейчас использовать? И однозначного ответа на него пока что нет.

    Лично я за использование Kotlin, так как не очень хочу только лишь ради build-системы изучать ещё один язык — Groovy. Наверно, для всего Android сообщества DSL на Kotlin существенно понижает порог вхождения в Gradle. Кроме того, у build-скриптов на Kotlin лучше поддержка в IDE с автокомплитом, но, тем не менее, она все еще далека от идеала.

    В качестве минуса Kotlin я бы выделил то, что могут встретиться какие-то старые плагины, которые изначально были заточены только под Groovy, и для их подключения придется потратить больше времени.

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

    #4 Как прописывать зависимости в многомодульных проектах

    Возьмем небольшой пример проекта со следующей структурой:

    Основной модуль, из которого собирается apk, зависит от feature-модулей, а также в нём прописаны какие-то внешние зависимости. feature-модули, в свою очередь, содержат транзитивные зависимости, которые могут пересекаться с зависимостями в других модулях.

    В чем проблема такого проекта? Здесь будет тяжело глобально обновлять зависимости в каждом из файлов. Очень легко забыть поднять версию в одном из скриптов, и тогда возникнут конфликты. По умолчанию Gradle умеет разрешать такие конфликты, выбирая максимальную версию, так что, скорее всего, сборка будет успешной (поведение можно менять через resolution strategy).

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

    Java platform plugin

    Разработчики Gradle предлагают для описания зависимостей создать отдельный специальный модуль, где будут описаны только зависимости с конкретными версиями. К этому модулю надо применить java platform plugin. Далее подключаем этот модуль в остальные модули и при указании каких-то внешних зависимостей не пишем конкретную версию:

    Такие platform-проекты можно даже публиковать на внешние maven репозитории и переиспользовать. В качестве минуса подхода можно назвать то, что при мажорных обновлениях библиотек часто меняются не только версии, но и названия модулей, и тогда все равно придется вносить изменения сразу в нескольких скриптах.

    Перейду к общепринятым в сообществе способам описания зависимостей.

    Описание зависимостей в extra properties

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

    В корневом проекте описываем зависимости. Вот кусок build-скрипта из библиотеки Google, где зависимость возвращается функцией compatibility :

    И обращаемся к ним из дочерних модулей:

    Описание зависимостей в скриптовом плагине

    Описанный способ с extra properties можно немного модифицировать и вынести описание зависимостей в скриптовый плагин, чтобы не засорять корневой проект. А уже скриптовый плагин можно применить или к корневому, или ко всем дочерним проектам сразу (через allprojects <> ), или к отдельным. Такой способ я тоже встречал.

    Описание зависимостей в buildSrc

    В buildSrc можно писать любой код, который будет компилироваться и добавляться в classpath build-скриптов. В последнее время стало популярно использовать buildSrc для описания там зависимостей. Например, в библиотеке Insetter Chris Banes так и делает.

    Все, что нужно, — это добавить синглтон со строками в buildSrc, и он станет виден всем модулям в проекте:

    Использовать buildSrc для зависимостей очень удобно, так как будут статические проверки и автокомплит в IDE:

    Но у этого решения есть один недостаток: любое изменение в buildSrc будет инвалидировать весь кэш сборки, что может быть несущественно для средних и маленьких проектов, но выливаться в серьезные проблемы для больших команд.

    Композитные сборки

    Можно достичь похожего результата со статическими проверками и автокомплитом, используя композитные сборки, при этом избавившись от проблемы инвалидации всего кэша. Я расскажу про него лишь кратко, а подробный гайд по миграции с buildSrc можно прочитать в статье из блога Badoo или статье от Josef Raska.

    В композитных сборках мы создаем так называемые «включенные сборки» (included build), в которых можно писать плагины и подключать их в своих модулях. Включенные сборки описываются в файле settings.gradle .

    Если мы хотим всего лишь подсунуть в classpath build-скриптов строки с зависимостями, то достаточно создать пустой плагин, а рядом с ним положить тот же файл с зависимостями, который мы использовали раньше в buildSrc:

    Все, что осталось сделать, — применить плагин к корневому проекту:

    И мы получим практически тот же результат, как и с использованием buildSrc.

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

    #5 Как обновлять зависимости

    В любом активном проекте надо постоянно следить за обновлением библиотек. IDE умеет подсвечивать для каждого модуля, описанного в блоке dependencies <> , наличие новых стабильных версий в репозиториях:

    Но этот инструмент работает только для зависимостей, описанных строковыми литералами в build-скриптах, а если мы попытаемся использовать способ с композитными сборками, buildSrc или extra properties, то IDE перестанет нам помогать. Кроме того, визуально просматривать build-скрипты в модулях, для того чтобы сделать обновление библиотек, на мой взгляд, не очень удобно.

    Но есть решение — использовать gradle-versions-plugin. Для этого просто применяем плагин к корневому проекту и регистрируем task для проверки новых версий зависимостей. Этот task надо настроить, передав ему лямбду для определения нестабильных версий:

    Теперь запуск команды ./gradlew dependencyUpdates выведет список зависимостей, для которых есть новые версии:

    #6 Старайтесь не использовать feature-флаги в build config

    Во многих проектах release, debug и другие сборки отличаются по функциональности. Например, в отладочных сборках могут быть включены какие-то логи, мониторинг сетевого трафика через прокси, debug menu для смены окружений и т.д. И часто для реализации такого используют флаги, прописанные в build config, например:

    А дальше такие флаги используются в коде приложения:

    И у такого решения есть недостатки. Довольно легко перепутать значения флагов и ветки if/else: if (enabled) <> else <> или if (disabled) <> else <> . Именно так однажды, во время рефакторинга, я случайно отправил в релиз то, что должно было включаться только в сборках для QA-отдела (думаю, у многих были похожие истории). Тогда проблему обнаружили оперативно, мы перевыпустили сборку в маркет. Кроме того, недостижимый код может быть скомпилирован и попасть в релиз (здесь я не буду рассуждать о том, что «мертвый» код может вырезаться из итогового приложения). Ну и многим известно, что любые операторы ветвления лучше заменять полиморфизмом. И в Gradle есть статический полиморфизм.

    Вместо флагов можно использовать разные source set для различных build variant («src/release/java . «, «src/debug/java . «). А если такой код хочется вынести в отдельные модули, то можно использовать специальные конфигурации: debugImplementation , releaseImplementation и т.д. Тогда мы сможем написать код с одним и тем же интерфейсом, но разной реализацией для различных типов сборок.

    Например, мы можем выделить debug menu в отдельный модуль и подключать его только для debug и QA-сборок:

    А stub реализацию для релизной сборки можно реализовать через source set.

    #7 Несколько слов про базовую структуру проекта

    Совет немного не по теме, но я решил добавить его как часть своего опыта, так как модуляризация напрямую связана с Gradle.

    Если для крупных проектов модуляризация кажется вполне очевидным решением, то не совсем понятно, как стоит поступать при старте небольших проектов или когда невозможно предсказать дальнейшее развитие кодовой базы продукта. Нужно ли выделять какие-то модули или достаточно начать с монолита? Я бы, помимо app модуля с основным приложением, всегда выделял как минимум два отдельных модуля:

    • UI kit: стили, кастомные элементы управления, виджеты и т.д. Обычно элементы управления на всех экранах приложения делаются консистентно в одном стиле (а возможно, у вас целая дизайн-система), и если в какой-то момент захочется выделить feature-модуль, то он также будет опираться на единый UI kit. Заранее подготовленный модуль с элементами управления и стилями упростит задачу и не потребует значительного рефакторинга приложения.
    • Common / utils: все утилитные классы и любые решения, которые не только потребуются в нескольких модулях, но и могут даже копироваться из проекта в проект. Особенно в контексте аутсорса такой модуль будет удобным при старте новых проектов. При вынесении классов в отдельный модуль, а не пакет, можно быть уверенным, что в его коде не окажется каких-либо бизнес сущностей конкретного приложения. Потенциально такой модуль может стать полноценной библиотекой, опубликованной в репозиторий.

    #8 Не забывайте про matchingFallbacks

    Часто, помимо debug и release , мы создаем и другие типы сборок, например, qa для тестов. И при создании модулей в приложении необязательно их прописывать в каждом build-скрипте. Достаточно при создании своего build type указать в модуле основного приложения те build type, которые следует выбирать при отсутствии каких-то конкретных:

    #9 Убирайте ненужные build variant

    Build variant формируются из всех возможных сочетаний product flavor и build type. Возьмем небольшой синтетический пример: создадим три build type – debug (отладочная сборка), release (сборка в маркет) и qa (сборка для тестирования), а во flavor вынесем разные сервера, на которые может смотреть сборка, – production и staging (тестовое окружение). Возможные build variant будут выглядеть так:

    Очевидно, что сборка в маркет, которая будет смотреть на тестовое окружение, совершенно бессмысленна и не нужна ( stagingRelease ). И чтобы исключить ее, можно добавить variant filter:

    #10 В некоторых модулях, завязанных на Android Framework, можно не использовать Android Gradle Plugin

    Если какой-то из ваших модулей завязан на классы из Android Framework, то вовсе не обязательно сразу применять к нему Android Gradle Plugin и писать там файл манифеста. Модули с AGP — более тяжеловесные, чем чистые java/kotlin модули, так как при сборке будут объединяться манифесты, ресурсы и т.д. Когда вам всего лишь требуется для компиляции модуля что-то вроде классов Activity , Context и т.д., то можно просто добавить Android Framework как зависимость:

    #11 Как написать Gradle-плагин для CI на примере gitlab

    Настройка CI — отдельная большая тема, которая потянет на целую увесистую статью. Но я решил немного коснуться её и рассказать, как при помощи написания Gradle-плагина настроить версионирование сборок. Возможно, этот совет поможет тем, кто только поднимает CI, но не знает, как лучше это сделать.

    Задача — сделать так, чтобы в сборках на CI versionCode ставился автоматически и представлял из себя последовательные номера 1, 2, 3 и т.д. Я встречал в своей практике, когда в качестве versionCode брался CI job id или каким-то образом использовался timestamp. В таких случаях versionCode с каждой новой версией повышался и был уникальным, но семантически такие версии выглядели достаточно странно.

    Основная идея проста — нужно хранить номер будущего релиза где-то во внешнем источнике, куда имеет доступ только сборка, выполняемая на CI. А после каждой успешной публикации нужно инкрементировать этот номер и перезаписывать (нам важно, чтобы сборка не просто успешно выполнилась, но и полученные артефакты распространились для тестировщиков). Стоит оговориться, что такое решение не позволит корректно делать одновременно несколько сборок. Всю эту логику достаточно просто оформить в Gradle-плагин. Как мы уже выяснили, плагины лучше писать, используя композитные сборки.

    В случае использования Gitlab CI подставляемый versionCode можно хранить в переменной окружения Gitlab. В его API есть метод для обновления переменных окружения: PUT /projects/:id/variables/:key . Для авторизации используем или project access token, или personal access token для старых версий gitlab.

    Расписал добавление такого плагина по шагам, чтобы показать, насколько это просто.

    Шаг 1: в настройках проекта на gitlab создать переменные окружения

    Нам понадобятся переменные VERSION_CODE_NEXT для хранения номера версии и токен для доступа к API gitlab:

    Шаг 2: создать композитную сборку

    Добавим в корне проекта директорию ./includedBuilds/ci , а в ней файл build.gradle.kts :

    Рядом создадим пустой файл ./includedBuilds/ci/settings.gradle.kts , если этого не сделать, то у вас сломается clean проекта.

    В корневом проекте в файл settings.gradle.kts добавим строку includeBuild(«includedBuilds/ci») .

    Шаг 3: написать плагин

    Так будет выглядеть метод для получения versionCode , его можно будет использовать в build-скрипте (можно добавить в любой файл: при применении плагина код будет скомпилирован и добавлен в classpath build-скрипта):

    Примерно так можно написать метод для обновления переменной на gitlab:

    Далее пишем task, который при выполнении будет инкрементировать версию:

    И напишем плагин, который добавит task в проект:

    Шаг 4: подключить плагин

    В build-скрипте проекта, из которого собирается apk, добавим следующие строки:

    Теперь команда ./gradlew assembleRelease appDistributionUploadRelease incrementVersionCode будет делать новую сборку, публиковать ее и инкрементировать версию. Остается добавить эту команду на нужный триггер в ваш скрипт в .gitlab-ci.yml .

    В заключение

    Думаю, что у многих есть свои best practices по работе с Gradle, которыми вы бы могли поделиться с сообществом. Или что-то описанное в этой статье можно сделать лучше. Так что буду рад увидеть ваши советы в комментариях.

    Что ещё посмотреть

    Мне очень помогли доклады про работу с Gradle, которые делал Степан Гончаров в разные годы. Ссылки на них, если кому-то интересна эта тема:

    Источник

    Читайте также:  Arraylist add all android
    Оцените статью