Было бы здорово, если Android Studio по вводу команды или по нажатию на кнопку автоматически собирал подписанный APK за вас, загружал его в Google Play Store и обновлял вас на вашей любимой платформе? Всего этого вы можете достичь, написав специальные задачи для каждой функции. Но что, если вы хотите сделать все то же самое, но для нескольких модулей или проектов? Тут-то на помощь и приходит использование плагина Gradle.

В сегодняшней статье мы напишем свой плагин Gradle. Он изменит название APK, переместит APK в вами выбранное место и создаст текстовый файл, в котором плагин добавит все зависимости для всех ваших APK, созданных с использованием этого плагина.

В процессе вы изучите следующие разделы:

• Задачи для Gradle
• Плагины для Gradle
• Разные способы завернуть плагин
• Объявление плагина локально

Итак, начнем

Загрузите материалы, используя кнопку «Загрузить материалы» вверху или внизу этой статьи. Распакуйте и откройте стартовый проект в вашей директории под названием ProjectTracker в Android Studio.

Запустите. Вы увидите что-то похожее на:

Это очень простое и понятное приложение. Когда пользователь что-то вводит в текстовое поле и нажимает на кнопку Enter Value, текст появляется на экране. Вот и все!

Вам не нужно беспокоиться о том, что происходит в приложении, так как вы будете работать с директорией buildSrc и файлами build.gradle.

Перед тем, как занырнуть в код и испачкать руки, очень важно понять, что такое Gradle и как создавать плагины с его помощью.

Что такое Gradle?

Gradle – это система автоматизации сборки с открытым исходным кодом, которая позволяет вам вникать в процесс сборки и ее логику. Например, когда вы собираете приложение, именно Gradle компилирует весь код и создает APK за вас. В этой статье вы вникните в процесс сборки и кастомизируете его под свои нужды.

Задачи для Gradle

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

Чтобы увидеть все задачи, запустите  ./gradlew tasks в терминале из корневой папки с проектом. Будут напечатаны все задачи:

Вы можете написать свою собственную задачу на модульном уровне файла build.gradle. Вот пример, найденный внутри директории приложения. Откройте его и добавьте код после блока plugins:

task printSomething() {
  doLast {
    println("Welcome to gradle world!")   
  }
}

Для выполнения созданной задачи в терминале запустите ./gradlew -q printSomething. Опция в командной строке -q пресекает сообщения лога Gradle, так, что выведется:

$ ./gradlew -q printSomething
Welcome to gradle world!

Метод doLast очень важен здесь, так как он сообщает Gradle выполнить действие, только когда задача вызвана. Без этого вы будете выполнять это действие во время конфигурации при каждый сборке. На деле также есть метод doFirst, который можно переписать. Если у вас есть:

task printSomething() {
  println("Before doFirst!")

  doFirst {
    println("In doFirst!")   
  }

  println("In between doFirst and doLast!")

  doLast {
    println("In doLast!")   
  }

  print("After doLast!")
}

Тогда после запуска ./gradlew printSomething будет выведено:

$ ./gradlew printSomething

> Configure project :
Before doFirst!
In between doFirst and doLast!
After doLast!
> Task :printSomething
In doFirst!
In doLast!

BUILD SUCCESSFUL in 8s
1 actionable task: 1 executed

Наличие методов doFirst и doLast позволяет расширять задачи и выполнять функционал в определенных часть жизненного цикла задачи.

Сборка плагина

Итак, вы знаете, что такое Gradle, каковы его задачи и как их увидеть. Вы также создали свою задачу и выполнили ее. Следующим по списку будет Gradle плагин. Этот плагин не более, чем комбинация из задач, которые вы хотели бы выполнить вместе. Есть несколько способов написать Gradle. Следующий раздел посвящен этому.

Сборочный скрипт

Поместите исходник плагина напрямую в файл build.gradle. Одно из преимуществ данного подхода является то, что класс автоматически компилируется и добавляется в путь класса этого скрипта. При этом вам не нужно что-либо конфигурировать. К недостатку можно отнести невозможность переиспользования плагина в другом модуле.

buildSrc проект

Еще способ – это поместить исходник плагина в директорию rootProjectDir/buildSrc/src/main/java. Пользой этого является возможность использовать плагин во всем проекте без привязки к какому-то конкретному модулю. Тем не менее, необходимо добавить несколько файлов, чтобы все заработало, а плагин не получится применить вне проекта.

Standalone проект

Вы также можете создать отдельный проект для плагина. Преимущество – после сборки проекта создается файл JAR, и он может быть использован в других ваших проектах Android Studio. Недостаток – для создания проекта с плагином Gradle вам необходимо использовать отдельный IDE (например, IntelliJ), а не Android Studio.

В этих примерах вы начнете с плагина в сборочном скрипте для простоты. Затем вы создадите buildSrc и standalone проекты.

Создание плагина в сборочном скрипте

Удалите ранее созданную задачу printSomething, так как плагин выполняет ту же работу.

Для создания плагина в сборочном скрипте добавьте следующие строчки в конец файла build.gradle:

class PrintClass implements Plugin {
  @Override
  void apply(Project project) {
    project.task("printSomething") {
      doLast {
        println("Welcome from gradle world!")
      }
    }
  }
}

Вы создали класс, который имплементирует generic класс Plugin и используется Project в виде параметра. Это вызовет метод apply класса плагина, а метод будет иметь тип Project в виде параметра. Вы можете использовать это для конфигурации проекта по вашему усмотрению. Внутри apply напишите задачу, используя параметр проекта.

Ваш плагин готов, но вы еще не применили его в проекте. Для этого напишите следующее в конце файла build.gradle:

apply plugin: PrintClass

Теперь вы можете выполнить команду ./gradlew -q printSomething в терминале и увидеть тот же результат.

Поздравляю! Вы создали свой первый плагин и можете вызывать задачу прямо из терминала 😊. Но этот плагин только печатает предложение и никак не конфигурирует проект. Ко всему прочему его можно использовать только в одном модуле. Отмените изменения, сделанные в этом разделе, и читайте далее, как создать плагин, используя директорию buildSrc.

Создание плагина, используя директорию buildSrc

Теперь создадим плагин по-другому. Сначала создайте директорию buildSrc в корне проекта. Именно там будет вся логика по сборке. А так, как она поддерживает Kotlin DSL, вы можете писать плагин на Kotlin.

Внутри новой директории создайте файл build.gradle.kts. Внутри этого файла добавьте код:

plugins {
  `kotlin-dsl`
}

repositories {
  mavenCentral()
}

Итак, что же здесь происходит? Для начала buildSrc – это та директория, на которую Gradle обращает внимание при компиляции. Если он находит специальный сборочный код, то добавляет его в путь класса.

В этом файле вы применяете плагин kotlin-dsl, но при попытке синхронизировать проект с его добавлением ничего не будет работать. Нужно также добавить mavenCentral() в repositories, потому что именно тут находится плагин. После добавления этих строчек синхронизируйте проект, и вы заметите еще несколько директорий в папке buildSrc. Структура вашего проекта будет выглядеть как-то так:

Это значит, что ваш файл build.gradle.kts был успешно добавлен в путь класса Gradle. Далее правой кнопкой мышки нажмите на папку buildSrc и выберете New ▸ Directory и далее src/main/java.

Здесь можно начать писать плагины на Kotlin, и все модули будут иметь доступ к ним. Откройте папку java и создайте класс на Kotlin BuildManager, который имплементирует Plugin.

import org.gradle.api.Plugin
import org.gradle.api.Project

class BuildManager : Plugin {
  override fun apply(project: Project) {
  }
}

Вы можете создавать задачи внутри метода apply по примеру того, как вы это делали в модуле build.gradle ранее. Для этого вы создадите задачу, которая не только распечатывает предложение.

Внутри apply добавьте этот код:

project.task("renameApk") {
 doLast {
   val apkPath = "/outputs/apk/release/app-release-unsigned.apk"
   val renamedApkPath = "/outputs/apk/release/RenamedAPK.apk"
   val previousApkPath = "${project.buildDir.absoluteFile}$apkPath"
   val newPath = File(previousApkPath)

   if (newPath.exists()) {
     val newApkName = "${project.buildDir.absoluteFile}$renamedApkPath"
       newPath.renameTo(File(newApkName))
   } else {
     println("Path does not exist!")
   }
 }
}.dependsOn("build")

Добавьте import для класса File вверху файла:

import java.io.File

Вы создаете задачу под названием renameApk и в этом классе находите расположение вашего APK, и затем переименовываете его. Но что, если APK еще не был создан? Или что, если вы удалили файл по какой-то причине? В этом случае последняя строка .dependsOn("build") приходит на помощь. Эта функция создаст зависимость в задаче build, которая предоставит APK.

Но при попытке выполнить задачу из терминала, приложение упадет и выдаст ошибку BUILD FAILED. Это все из-за того, что вы не применили плагин к проекту. Чтобы это исправить, перейдите в файл build.gradle.kts и добавьте следующее:

gradlePlugin {
  plugins {
    create("BuildManager") {
      id = "com.raywenderlich.plugin"
      implementationClass = "BuildManager"
      version = "1.0.0"
    }
  }
}

В коде выше вы регистрируете ваш плагин путем использования одного из расширений функций – gradlePlugin. Используя функцию create, можно сообщить имя, ID, версию и ссылку на плагин класса, который вы создали.

Самое время добавить зарегистрированный плагин в ваш модуль. Перейдите в файл build.gradle и добавьте его в конец списка задач plugins:

plugins {
  ...
  id 'com.raywenderlich.plugin'
}

Вот и все! Синхронизируйте проект, запустите ./gradlew clean для очистки директории build и выполните задачу через ./gradlew -q renameApk. Перейдите в папку /app/build/outputs/apk/release и найдите переименованный APK.

Управление зависимостью

Перед добавлением новых фич в ваш плагин вам предстоит немного очистить ваш проект. Создайте новый Kotlin файл в папе java и назовите его Constant. Добавьте этот код:

import java.time.LocalDateTime
import java.time.format.DateTimeFormatter

object Dependencies {
  const val kotlinCore = "androidx.core:core-ktx:${Versions.kotlinCoreVersion}"
  const val appCompat = "androidx.appcompat:appcompat:${Versions.appCompatVersion}"
  const val material = "com.google.android.material:material:${Versions.materialVersion}"
  const val constraint = "androidx.constraintlayout:constraintlayout:${Versions.constraintVersion}"
  const val jUnit = "junit:junit:${Versions.jUnitVersion}"
  const val jUnitExt = "androidx.test.ext:junit:${Versions.jUnitExtVersion}"
  const val espresso = "androidx.test.espresso:espresso-core:${Versions.espressoVersion}"

  const val kotlinStdLib = "org.jetbrains.kotlin:kotlin-stdlib:${Versions.kotlinStdLibVersion}"
  const val kotlinGradlePlugin = "org.jetbrains.kotlin:kotlin-gradle-plugin:${Versions.kotlinStdLibVersion}"
  const val buildToolGradle = "com.android.tools.build:gradle:${Versions.buildToolGradleVersion}"
}

object Versions {
  const val compileSdkVersion = 30
  const val buildToolsVersion = "30.0.3"
  const val minSdkVersion = 21
  const val targetSdkVersion = 30

  const val kotlinStdLibVersion = "1.4.32"
  const val buildToolGradleVersion = "4.1.3"

  const val kotlinCoreVersion = "1.3.2"
  const val appCompatVersion = "1.2.0"
  const val materialVersion = "1.3.0"
  const val constraintVersion = "2.0.4"
  const val jUnitVersion = "4.13.2"
  const val jUnitExtVersion = "1.1.2"
  const val espressoVersion = "3.3.0"
}

object AppDetail {
  const val applicationId = "com.raywenderlich.projecttracker"
  const val appName = "ProjectTracker"
  const val versionCode = 1
  const val versionName = "1.0.0"

  // Change these values as needed
  const val previousPath = "/outputs/apk/release"
  const val targetPath = "newOutput"

  const val previousName = "app-release-unsigned.apk"
  val newApkName = "$appName-${getDate(false)}($versionCode).apk"

  const val dependencyFileName = "Dependencies.txt"
}


fun getDate(forTxtFile: Boolean): String {
  val current = LocalDateTime.now()
  val formatter = if (forTxtFile) {
    DateTimeFormatter.ofPattern("dd MMM, yyy")
  } else {
    DateTimeFormatter.ofPattern("yyyyMMdd")
  }
  return current.format(formatter)
}

Классы Dependencies, Version и AppDetail будут использованы для управления зависимостями. Вы также будете применять класс AppDetail и функцию getDate() для добавления нового функционала в ваш плагин. В данный момент все это делается для сборки информации в классах. Далее вы можете перейти в файлы Gradle и обновить ваши зависимости, чтобы они выглядели опрятнее и ими было удобнее управлять.

После этих изменений ваш файл build.gradle будет выглядеть примерно так:

plugins {
  id 'com.android.application'
  id 'kotlin-android'
  id 'com.raywenderlich.plugin'
}

android {
  compileSdkVersion Versions.compileSdkVersion
  buildToolsVersion Versions.buildToolsVersion

  defaultConfig {
    applicationId AppDetail.applicationId
    minSdkVersion Versions.minSdkVersion
    targetSdkVersion Versions.targetSdkVersion
    versionCode AppDetail.versionCode
    versionName AppDetail.versionName

    testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
  }

  buildTypes {
    release {
      minifyEnabled false
      proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
    }
  }
  compileOptions {
    sourceCompatibility JavaVersion.VERSION_1_8
    targetCompatibility JavaVersion.VERSION_1_8
  }
  kotlinOptions {
    jvmTarget = '1.8'
  }
}

dependencies {
  implementation Dependencies.kotlinStdLib
  implementation Dependencies.kotlinCore
  implementation Dependencies.appCompat
  implementation Dependencies.material
  implementation Dependencies.constraint
  testImplementation Dependencies.jUnit
  androidTestImplementation Dependencies.jUnitExt
  androidTestImplementation Dependencies.espresso
}

И на верхнем уровне/проектном уровне файл build.gradle будет выглядеть так:

buildscript {
  repositories {
    google()
    mavenCentral()
  }
  dependencies {
    classpath Dependencies.buildToolGradle
    classpath Dependencies.kotlinGradlePlugin
  }
}

allprojects {
  repositories {
    google()
    mavenCentral()
  }
}

task clean(type: Delete) {
  delete rootProject.buildDir
}

А теперь самое время добавить больше задач в класс плагина.

Добавляем больше задач

Можно создать больше задач в функции apply, как это делали с renameApk, но лучше разделить задачи по разным классам для чистоты кода и переиспользования.

Создайте папку внутри папки java и назовите ее tasks. Внутри нее создайте новый Kotlin класс ManageApk.

В этот класс добавьте:

package tasks

import AppDetail.newApkName
import AppDetail.previousName
import AppDetail.previousPath
import AppDetail.targetPath
import org.gradle.api.DefaultTask
import org.gradle.api.tasks.TaskAction
import java.io.File

open class ManageApk: DefaultTask() {
  @TaskAction
  fun renameApk() {
    val newPath = File("${project.buildDir.absoluteFile}/$previousPath/$previousName")
    if (newPath.exists()) {
      val newApkName = "${project.buildDir.absoluteFile}/$previousPath/$newApkName"
      newPath.renameTo(File(newApkName))
    } else {
      println("Path not exist!")
    }
    moveFile()
  }

  private fun moveFile() {
    File("${project.buildDir.absoluteFile}/$previousPath/$newApkName").let { sourceFile ->
      try {
        sourceFile.copyTo(File("$targetPath/$newApkName"))
      } catch (e: Exception) {
        e.printStackTrace()
        val folder = File(targetPath)
        folder.mkdir()
      } finally {
        sourceFile.delete()
      }
    }
  }
}

Расширяя класс с помощью DefaultTask, вы имеете возможность определять ваши собственные задачи. Для этого вам нужно объявить функцию с @TaskAction и затем записать собственную логику внутри. Функция moveFile переместит созданный APK, куда вы захотите (убедитесь, что вы поменяли положение внутри Constans.kt). Ваш класс task готов.

Для его использования в вашем плагине откройте ваш плагин-класс BuildManager и внутри apply() замените существующий код на:

project.tasks.register("renameApk") {
  dependsOn("build")
}

Добавьте также следующие зависимости:

import org.gradle.kotlin.dsl.register
import tasks.ManageApk

Вы только что зарегистрировали задачу, которую создали в вашем классе ManageApk в вашем плагин-классе. Задача будет выполнена при вызове renameApk. Последнее зависит от задачи build.

Теперь синхронизируйте и запустите ./gradlew clean для очистки проекта. В терминале запустите ./gradlew -q renameApk, и ваш APK будет переименован согласно имени, данному приложению в Constant.kt. Его суффикс должен быть сегодняшней датой и предоставленной вами версией кода. Он также переместит APK, куда вы захотите.

И финальные штрихи. Создайте ManageDependency.kt внутри директории tasks и добавьте код:

package tasks

import AppDetail.dependencyFileName
import AppDetail.targetPath
import getDate
import org.gradle.api.DefaultTask
import org.gradle.api.tasks.TaskAction
import java.io.File

open class ManageDependency : DefaultTask() {
  @TaskAction
  fun saveDependencies() {
    var file = File("$targetPath/$dependencyFileName")
    if (!file.exists()) {
      println("Path does not exist. Creating folder...")

      val folder = File(targetPath)
      if (!folder.exists()) {
        folder.mkdir()
      }
        
      file = File(targetPath, dependencyFileName)
      file.createNewFile()
    }
    writeDependencies(file)
  }

  private fun writeDependencies(file: File) {
    file.appendText(getDate(true), Charsets.UTF_8)
    file.appendText(
        "\n${AppDetail.appName} - ${AppDetail.versionName}(${AppDetail.versionCode})\n",
        Charsets.UTF_8
    )
    file.appendText("====Dependencies====\n", Charsets.UTF_8)

    project.configurations.asMap.forEach {
      if (it.key.contains("implementation")) {
        it.value.dependencies.forEach { dependency ->
          file.appendText(
              "${dependency.group}:${dependency.name}:${dependency.version}\n",
              Charsets.UTF_8
          )
        }
      }
    }

    file.appendText("====================", Charsets.UTF_8)
    file.appendText("\n\n\n", Charsets.UTF_8)
  }
}

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

project.tasks.register("saveDependencies") {
  dependsOn("renameApk")
}

project.task("createBuild").dependsOn("saveDependencies")

Импортируйте это:

import tasks.ManageDependency

И вот так будет выглядет класс BuildManager:

import org.gradle.api.Plugin
import org.gradle.api.Project
import org.gradle.kotlin.dsl.invoke
import org.gradle.kotlin.dsl.register
import task.ManageApk
import task.ManageDependency

class BuildManager : Plugin {
  override fun apply(project: Project) {
    project.tasks.register("renameApk") {
      dependsOn("build")
    }

    project.tasks.register("saveDependencies") {
      dependsOn("renameApk")
    }

    project.task("createBuild").dependsOn("saveDependencies")
  }
}

Теперь можно протестировать созданный плагин. Для начала удалите папку newOutput. Запустите ./gradlew clean для удаления директории со сборкой и затем вызовите ./gradlew -q createBuild в терминале для теста.

На этом все по созданию плагина Gradle в buildSrc!! Наконец вы изучите как создать плагин в standalone проекте в следующем разделе.

Создание плагина для standalone проекта

Для этого проекта не нужно придумывать что-то хитрое – просто создается плагин, который добавляет текстовый файл и зависимости в этом файле. Создание standalone проекта дает вам возможность публиковать и делиться им с другими. Предпочтительный и самый простой способ – это использование плагина Java Gradle. Он автоматически добавит зависимость gradleApi(), сгенерирует необходимые дескрипторы плагина в итоговом JAR файле и сконфигурирует Plugin Marker Artifact для пользования после публикации.

Для начала разахрхивируйте и откройте стартовый проект с названием ProjectTrackerPlugin в IntelliJ.

В build.gradle добавьте java-gradle-plugin и maven внутри задач plugins. Будет выглядеть примерно так:

plugins {
  id 'java'
  id 'java-gradle-plugin'
  id 'maven'
  id 'org.jetbrains.kotlin.jvm' version '1.4.32'
}

Эти два плагина помогут создать плагин и опубликовать его. После внесения изменений загрузите их с помощью команды Command-Shift-I для macOS или Control-Shift-O для ПК. Далее создайте package внутри директории src/main/kotlin и назовите его com.raywenderlich.plugin. Внутри создайте Kotlin класс SaveDependencyTask и расширьте его с DefaultTask().

Создайте companion object и добавьте следующие константы, которые помогут определить, куда сохранить текстовый файл:

companion object {
  private const val targetPath = "newOutput"
  private const val dependencyFileName = "Dependencies.txt"
}

Создайте переменную configuration типа Collection и объявите ее с @Input:

@Input
var configuration: Collection = mutableListOf()

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

Далее создайте функцию checkDependency и добавьте аннотацию через @Input. Внутри функции:

var file = File("$targetPath/$dependencyFileName")
if (!file.exists()) {
  println("Path does not exist. Creating folder...")

  val folder = File(targetPath)
  if (!folder.exists()) {
    folder.mkdir()
  }
  
  file = File(targetPath, dependencyFileName)
  file.createNewFile()
}
writeDependencies(file)

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

И, наконец, добавьте оставшиеся функции, которые фактически будут выполнять запись в текстовый файл:

private fun writeDependencies(file: File) {
  file.appendText(getDate(), Charsets.UTF_8)
  file.appendText("\n====Dependencies====\n", Charsets.UTF_8)
  configuration.forEach {
    project.configurations.getByName(it).dependencies.forEach { dependency ->
      file.appendText(
          "${dependency.group}:${dependency.name}:${dependency.version}\n",
          Charsets.UTF_8
      )
    }
  }
  file.appendText("====================", Charsets.UTF_8)
  file.appendText("\n\n\n", Charsets.UTF_8)
}

private fun getDate(): String {
  val current = LocalDateTime.now()
  val formatter = DateTimeFormatter.ofPattern("dd MMM, yyy")
  return current.format(formatter)
}

После этого ваша задача готова. Теперь создайте Kotlin класс в той же директории и назовите его SaveDependancy и имплементируйте Plugin. В применимой функции зарегистрируйте созданную задачу:

package com.raywenderlich.plugin

import org.gradle.api.Plugin
import org.gradle.api.Project

class SaveDependency: Plugin {
  override fun apply(project: Project) {
    project.tasks.register("writeModuleDependencies", SaveDependencyTask::class.java)
  }
}

Вуаля! Вы сделали собственный Gradle плагин в standalone проекте.

Далее посмотрим, как использовать этот плагин в проектах Android Studio.

Публикация плагина в локальную директорию

Ваш плагин готов! Для публикации в вашу локальную директорию откройте файл build.gradle в вашем проекте IntelliJ и добавьте:

uploadArchives {
  repositories.mavenDeployer {
    repository(url: uri('pluginOutput'))
  }
}

После добавления кода снова синхронизируйте изменения Gradle. Эта задача опубликует ваш плагин в желаемом месте. Вы можете выполнить задачу, щелкнув зеленую кнопку воспроизведения рядом с задачей или выполнив команду ./gradlew -q uploadArchives в терминале. Скомпилируйте и запустите, и вы увидите директорию плагина в желаемом месте.

Затем вы будете использовать его в своем проекте Android Studio. Снова запустите проект ProjectTracker и откройте файл build.gradle на уровне проекта. Внутри repositories в блоке buildscript добавьте:

maven {
  url uri('path/to/standalone/plugin/project')
}

И добавьте в задачу dependencies:

classpath group: 'com.raywenderlich', name: 'ProjectTrackerPlugin', version: '1.0.0'

Теперь ваш проект имеет доступ к файлам плагина. Для его применения откройте на уровне модуля файл build.gradle и добавьте следующие строки в файл Gradle:

writeModuleDependencies {
  configuration = ["implementation"]
}

В итоге вы можете вызвать задачу в файле build.gradle, добавив в самый низ:

writeModuleDependencies {
  configuration = ["implementation"]
}

Запустите ./gradlew clean для очистки Gradle и вызовите ./gradlew -q writeModuleDependencies. Наслаждайтесь вашим плагином!

Что дальше?

Вы можете загрузить окончательный проект, нажав кнопку Download Materials.

Фух! В этом руководстве вы узнали о многих вещах. Теперь вы можете создать свой собственный плагин Gradle и использовать его в разных проектах.

И это еще не все! Чтобы узнать больше о плагине Gradle и о том, что еще вы можете с ним сделать, ознакомьтесь с официальной документацией Gradle.

Оригинал статьи