O que e Gradle Plugin em Kotlin?

Um Gradle Plugin e um modulo que estende as capacidades do sistema de build Gradle, adicionando tarefas, configuracoes e convencoes ao projeto. No ecossistema Kotlin, o plugin mais importante e o Kotlin Gradle Plugin (org.jetbrains.kotlin.jvm, org.jetbrains.kotlin.multiplatform, etc.), que ensina o Gradle a compilar codigo Kotlin.

Alem do plugin oficial do Kotlin, existem dezenas de plugins que automatizam tarefas comuns: serializacao, geracaco de codigo, analise estatica, publicacao de bibliotecas e muito mais.

Aplicando o Kotlin Gradle Plugin

A forma moderna de aplicar plugins usa o bloco plugins no build.gradle.kts:

plugins {
    kotlin("jvm") version "1.9.22"
}

repositories {
    mavenCentral()
}

dependencies {
    implementation(kotlin("stdlib"))
    testImplementation(kotlin("test"))
}

Para projetos Android:

plugins {
    id("com.android.application")
    kotlin("android") version "1.9.22"
}

Para projetos multiplataforma:

plugins {
    kotlin("multiplatform") version "1.9.22"
}

kotlin {
    jvm()
    iosArm64()
    iosSimulatorArm64()

    sourceSets {
        commonMain.dependencies {
            implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3")
        }
    }
}

Plugins comuns no ecossistema Kotlin

O ecossistema Kotlin tem varios plugins essenciais:

plugins {
    kotlin("jvm") version "1.9.22"
    kotlin("plugin.serialization") version "1.9.22" // kotlinx.serialization
    id("com.google.devtools.ksp") version "1.9.22-1.0.17" // KSP
    id("org.jetbrains.compose") version "1.5.12" // Compose Multiplatform
}

Cada plugin adiciona funcionalidades especificas:

  • kotlin-serialization: gera codigo de serializacao em tempo de compilacao.
  • KSP (Kotlin Symbol Processing): processa anotacoes e gera codigo.
  • Compose: habilita o compilador do Jetpack Compose.

Criando um Gradle Plugin customizado

Voce pode criar seus proprios plugins para automatizar tarefas especificas do projeto. A forma mais simples e um plugin no buildSrc:

// buildSrc/src/main/kotlin/MeuPlugin.kt
import org.gradle.api.Plugin
import org.gradle.api.Project

class MeuPlugin : Plugin<Project> {
    override fun apply(projeto: Project) {
        projeto.tasks.register("saudacao") {
            group = "custom"
            description = "Exibe uma saudacao"
            doLast {
                println("Ola do MeuPlugin!")
            }
        }
    }
}

// buildSrc/build.gradle.kts
plugins {
    `kotlin-dsl`
}

repositories {
    mavenCentral()
}

// build.gradle.kts (no projeto principal)
plugins {
    id("meu-plugin") // Registrado automaticamente pelo buildSrc
}

Plugin com extension (configuracao customizada)

Plugins mais sofisticados usam extensions para permitir configuracao:

// Definir a extension
open class MinhaConfiguracao {
    var nomeDoApp: String = "MeuApp"
    var versao: String = "1.0.0"
    var habilitarLogs: Boolean = false
}

class PluginConfiguravelPlugin : Plugin<Project> {
    override fun apply(projeto: Project) {
        val config = projeto.extensions.create("minhaConfig", MinhaConfiguracao::class.java)

        projeto.afterEvaluate {
            projeto.tasks.register("info") {
                doLast {
                    println("App: ${config.nomeDoApp}")
                    println("Versao: ${config.versao}")
                    println("Logs: ${config.habilitarLogs}")
                }
            }
        }
    }
}

Uso no build.gradle.kts:

minhaConfig {
    nomeDoApp = "KotlinBrasil"
    versao = "2.0.0"
    habilitarLogs = true
}

Convention Plugins

Uma pratica moderna e criar convention plugins que padronizam configuracoes em projetos multi-modulo:

// build-logic/convention/src/main/kotlin/kotlin-library-convention.gradle.kts
plugins {
    kotlin("jvm")
}

kotlin {
    jvmToolchain(17)
}

tasks.withType<Test> {
    useJUnitPlatform()
}

dependencies {
    testImplementation(kotlin("test"))
}

// Qualquer modulo do projeto
plugins {
    id("kotlin-library-convention")
}
// Automaticamente herda todas as configuracoes do convention plugin

Isso evita duplicacao de configuracao entre modulos e garante consistencia.

Version Catalogs com plugins

O Gradle Version Catalog centraliza versoes de dependencias e plugins:

# gradle/libs.versions.toml
[versions]
kotlin = "1.9.22"
ksp = "1.9.22-1.0.17"

[plugins]
kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
ksp = { id = "com.google.devtools.ksp", version.ref = "ksp" }

// build.gradle.kts
plugins {
    alias(libs.plugins.kotlin.jvm)
    alias(libs.plugins.kotlin.serialization)
}

Quando usar Gradle Plugins

  • Compilacao de Kotlin: o plugin kotlin-jvm ou kotlin-multiplatform e obrigatorio para compilar Kotlin.
  • Geracao de codigo: plugins como KSP e serialization geram codigo em tempo de compilacao, evitando boilerplate.
  • Padronizacao: convention plugins garantem que todos os modulos de um projeto seguem as mesmas regras.
  • Automacao: tarefas repetitivas como publicacao, geracao de documentacao e analise de codigo podem ser automatizadas com plugins.
  • Integracao: plugins conectam o build a ferramentas externas como Docker, Kubernetes, AWS.

Erros comuns

  1. Versao incompativel entre plugins: o Kotlin Gradle Plugin, KSP e outros plugins precisam ter versoes compativeis. Verifique a matriz de compatibilidade antes de atualizar.

  2. Aplicar plugins na ordem errada: em projetos Android, o plugin Android deve ser aplicado antes do Kotlin. A ordem dos plugins pode afetar o comportamento do build.

  3. Usar apply em vez de plugins: a sintaxe antiga apply plugin: 'kotlin' ainda funciona, mas a DSL plugins { } e type-safe e preferida.

  4. Configurar o plugin fora do bloco correto: cada plugin tem seu bloco de configuracao especifico. Configurar no lugar errado causa erros silenciosos ou inesperados.

  5. Nao cachear builds: o Kotlin Gradle Plugin suporta incremental compilation e build cache. Nao configurar isso pode deixar o build muito mais lento do que necessario.

Tarefas uteis do Kotlin Gradle Plugin

# Compilar o projeto
./gradlew compileKotlin

# Executar testes
./gradlew test

# Verificar dependencias
./gradlew dependencies

# Limpar e reconstruir
./gradlew clean build

Termos relacionados

  • KSP (Kotlin Symbol Processing): plugin para processamento de anotacoes e geracao de codigo em Kotlin.
  • Kotlin Multiplatform: plugin que habilita compilacao para multiplas plataformas.
  • Serialization: plugin que gera serializadores em tempo de compilacao.
  • buildSrc: diretorio especial do Gradle para logica de build compartilhada.
  • Version Catalog: sistema de gerenciamento centralizado de versoes de dependencias e plugins.
  • Convention Plugin: plugin que padroniza configuracoes entre modulos de um projeto.

Gradle Plugins sao a espinha dorsal do sistema de build no ecossistema Kotlin. Entender como aplica-los, configura-los e, quando necessario, cria-los, e uma habilidade essencial para qualquer desenvolvedor Kotlin que trabalhe em projetos profissionais.