class MyPlugin : Plugin<Project> { 
  override fun apply(project: Project) {
    //…
  }
}

plugins {
  `kotlin-dsl`
}

apply<MyPlugin>()

gradlePlugin { 
  plugins {
    register(“first-plugin”) {
      description = "My first plugin"
      displayName = "Does nothing"
      id = “ru.myorg.demo.my-plugin”
      implementationClass = "ru.myorg.demo.MyPlugin"   
    }
  }
}

implementation-class=ru.myorg.demo.MyPlugin

plugins {
  //...
  id("ru.myorg.demo.my-plugin")
}

implementation("com.android.tools.build:gradle:$agpVersion")
//4.1.2

plugins {
  id("com.android.library")
  id("kotlin-android")
}
android {  
  compileSdkVersion(androidCompileSdkVersion)
  buildToolsVersion(androidBuildToolsVersion)
  defaultConfig {
    minSdkVersion(androidMinSdkVersion)
    targetSdkVersion(androidTargetSdkVersion)
  }   
  sourceSets["main"].java.srcDirs("src/main/kotlin")
  sourceSets["test"].java.srcDirs("src/test/kotlin")
}

class AndroidLibraryPlugin: Plugin<Project> { 
  override fun apply(target: Project) = target.applyAndroid()
  private fun Project.applyAndroid() { 
    plugins.run {
      apply("com.android.library")
      apply("kotlin-android")
    }
    android {     
    //...
    }
  }
}

fun Project.android(action: BaseExtension.() -> Unit) =
  (extensions["android"] as BaseExtension).run(action)

val PluginDependenciesSpec.`android-library-common`: PluginDependencySpec
  get() = id("ru.myorg.demo.android-library-common")

plugins {
  `android-library-common`
}

plugins { 
  `kotlin-dsl`
}
repositories {
  mavenCentral()
}
dependencies {
  implementation("com.squareup:kotlinpoet:1.7.2")
  implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:1.5.10")
}

open class CodegenPluginExtension(project: Project) {
  private val objects = project.objects
  private val packageNameProp: Property<String> = objects.property<String>()
    .convention("ru.myorg.demo")
  private val messageFileProperty = objects.fileProperty() 
  private val outputDirProperty = objects.directoryProperty()
    .convention(project.layout.buildDirectory.dir("src-gen"))
  var messageFile: RegularFile 
      get() = messageFileProperty.get() 
      set(value) = messageFileProperty.set(value)
  var outputDir: Directory   
      get() = outputDirProperty.get()   
      set(value) = outputDirProperty.set(value) 
  var packageName: String   
      get() = packageNameProp.get()   
      set(value) = packageNameProp.set(value)
}

override fun apply(target: Project) {
  //...
  val extension: CodegenPluginExtension =
  target.extensions.create("simpleCodegen", target)
}

simpleCodegen { 
  //...
}

open class CodegenTask : DefaultTask() { 
  @get:InputFile
  lateinit var messageFile: File 
  @get:Input
  lateinit var packageName: String 
  @get:OutputDirectory 
  lateinit var outputDir: File 
  @TaskAction 
  fun invoke() { 
    val messageProvider = FileMessageProvider(messageFile)
    val simpleFileGenerator = SimpleMessageClassGenerator(messageProvider) 
    simpleFileGenerator.generate(packageName, outputDir) 
  }
}

(target.extensions["sourceSets"] as SourceSetContainer)["main"]
  .java
  .srcDir(extension.outputDir)

with(target.tasks) {
  val codegenTask = register<CodegenTask>("codegenSimpleClass") {
    group = "Code generation"
    description = "Generates Kotlin class with single message property"
    packageName = extension.packageName
    messageFile = extension.messageFile.asFile
    outputDir = extension.outputDir.asFile
  }
  target.tasks.withType<KotlinCompile>() {
    dependsOn(codegenTask)
  }
}

class CodegenPlugin : Plugin<Project> {
  override fun apply(target: Project) {
    val extension = target.extensions.create<CodegenPluginExtension>("simpleCodegen", target)
    with(target.tasks) {
      val codegenTask = register<CodegenTask>("codegenSimpleClass") {
        group = "Code generation"
        description = "Generates simple Kotlin class with single message property"
        packageName = extension.packageName
        messageFile = extension.messageFile.asFile
        outputDir = extension.outputDir.asFile
      }
      target.tasks.withType<KotlinCompile> {
        dependsOn(codegenTask)
      }
    }
    (target.extensions["sourceSets"] as SourceSetContainer)["main"]
      .java
      .srcDir(extension.outputDir)
  }
}

pluginManagement {
  includeBuild("../standalone-codegen-plugin")
}

simpleCodegen { 
  messageFile = layout.projectDirectory.file("message.txt") 
  packageName = "ru.myorg.example"
}

val integrationTest: SourceSet by sourceSets.creating
val functionalTest: SourceSet by sourceSets.creating
val integrationTestTask = tasks.register<Test>("integrationTest") { 
  description = "Runs the integration tests."
  group = "verification" 
  testClassesDirs = integrationTest.output.classesDirs 
  classpath = integrationTest.runtimeClasspath 
  mustRunAfter(tasks.test)
}
val functionalTestTask = tasks.register<Test>("functionalTest") { 
  description = "Runs the functional tests." 
  group = "verification" 
  testClassesDirs = functionalTest.output.classesDirs 
  classpath = functionalTest.runtimeClasspath 
  mustRunAfter(tasks.test)
}
tasks.check { 
  dependsOn(integrationTestTask)
  dependsOn(functionalTestTask)
}
dependencies { 
  "integrationTestImplementation"(project) 
  "integrationTestImplementation"("junit:junit:4.12") 
  "functionalTestImplementation"("junit:junit:4.12")
}

class SimpleMessageClassGeneratorTest { 
  @get:Rule
  val tempFolder = TemporaryFolder() 
  @Test 
  fun verifyCorrectKotlinFileCreated() {   
    val message = "Hello!"
    val messageProvider = MessageProvider { message }   
    val simpleMessageClassGenerator = SimpleMessageClassGenerator(messageProvider)
    val expectedKotlinClass = "package ru.myorg.demo\n" +
    "\n" +
    "import kotlin.String\n" +       
    "\n" +       
    "public class SimpleClass {\n" +       
    "  public val message: String = "Hello!"\n" +       
    "}\n"   
    simpleMessageClassGenerator.generate(
      packageName = "ru.myorg.demo",
      outputDir = tempFolder.root
    )   
    val generatedFile = File(
      tempFolder.root,
      "/ru/myorg/demo/SimpleClass.kt"
    )   
    assert(
      generatedFile.exists() &&
        generatedFile.readText() == expectedKotlinClass
    )
  }

gradlePlugin { 
  //...
  testSourceSets(functionalTest)
}

class CodegenPluginTest {
  @get:Rule
  val tempFolder = TemporaryFolder()
  @Test
  fun canSuccessfullyPrintMessageToFileInProjectDir() {
    /**
     * Готовим сообщение message
     */
    val messageFileName = "message.txt"
    val messageFile = tempFolder.newFile(messageFileName)
    messageFile.bufferedWriter().write("Hello!")
    /**
     * Готовим build.gradle
     */
    val generatedPackageName = "ru.myorg.demo.example"
    val buildGradleFile = tempFolder.newFile("build.gradle.kts")
    buildGradleFile.printWriter()
      .use {
        it.print(
          "plugins {\n" +
              "  kotlin("jvm") version "1.5.10"\n" +
              "  id("ru.myorg.demo.codegen-plugin")\n" +
              "}\n" +
              "\n" +
              "simpleCodegen {\n" +
              "  messageFile = layout.projectDirectory.file("$messageFileName")\n" +
              "  packageName = "$generatedPackageName"\n" +
              "}\n" +
              "\n" +
              "repositories {\n" +
              "  mavenCentral()\n" +
              "}\n" +
              "\n" +
              "dependencies {\n" +
              "  implementation(kotlin("stdlib"))\n" +
              "}"
        )
      }
    /**
     * Запускаем Gradle Daemon и билдим проект.
     */
    GradleRunner.create()
      .withProjectDir(tempFolder.root)
      .withArguments("build")
      .withPluginClasspath()
      .build()
    /**
     * Смотрим, что создалось. Содержимое файла мы уже проверили в интеграционном тесте.
     */
    val outputFile =
      File(
        tempFolder.root,
        "/build/src-gen/" +
          generatedPackageName.replace('.', '/') +
          "/SimpleClass.kt"
      )
    assert(outputFile.exists())
  }
}

plugins {
  //...
  `maven-publish`
}
publishing {
  publications {
    create<MavenPublication>("codegen-plugin") {
      artifactId = "codegen-plugin"
      groupId = "ru.myorg.demo"
      version = "1.0.0"
      from(components["kotlin"])
    }
  }
  repositories {
    maven {
      name = "remote"
      url = uri("https://some-remote-repo")
      credentials {
        username = project.ext["MY_REMOTE_REPO_USERNAME"] as String
        password = project.ext["MY_REMOTE_REPO_PASSWORD"] as String
      }
    }
  }
}