Convention Plugins no Android: Otimizando Build Scripts com Plugins Personalizados

Douglas Motta
Douglas Motta
1 min read

Convention Plugins no Android: Otimizando Build Scripts com Plugins Personalizados

No desenvolvimento Android, a complexidade dos scripts de build cresce rapidamente conforme o projeto escala. Manter configurações consistentes e evitar duplicações entre módulos é um desafio comum. É neste cenário que os convention plugins — plugins personalizados para Gradle — surgem como aliados poderosos. Eles promovem organização, reaproveitamento e padronização no processo de build.

Aqui, você vai aprender o que são os convention plugins, por que são importantes para projetos Android modernos, e como aplicá-los de forma prática para melhorar a manutenção do seu código de build.

O que são Convention Plugins?

Convention plugins são plugins Gradle criados pela equipe de desenvolvimento do projeto para encapsular convenções e configurações padrão que se repetem em múltiplos módulos. Ao invés de duplicar configurações complexas em cada arquivo build.gradle.kts (Kotlin DSL) ou build.gradle, essas regras são centralizadas em um plugin customizado.

Diferente dos plugins externos, que são pacotes típicos fornecidos pela comunidade ou Google (ex: com.android.application, org.jetbrains.kotlin.jvm), os convention plugins são controlados pelo time e integram diretamente as diretrizes internas do projeto.

Características principais:

  • Centralizam configurações comuns (ex: versões, regras de lint, scripts de teste)
  • Simplificam arquivos de build, aplicando um único plugin que traz tudo pré-configurado
  • Permitem evoluções e padronizações sem precisar alterar dezenas de módulos individualmente

Por que importa para devs Android?

Com a popularização do Kotlin DSL e a escalabilidade dos projetos Android (multimódulos, multiplataforma etc.), o build system passou a demandar:

  • Manutenção mais fácil: Mudanças em uma convenção precisam ocorrer em um só lugar
  • Consistência: Garantir que todos os módulos usem as mesmas versões, parâmetros e plugins auxiliares
  • Performance: Gradle se beneficia da configuração mais limpa e compartilhada para otimizar builds

Projetos grandes, com múltiplos times, encontram nesses plugins um mecanismo para desacoplar lógica de build do código da aplicação, além de tornar onboarding e manutenção mais ágil.

Como aplicar Convention Plugins no mundo real

Estrutura típica

  1. Criar um módulo Gradle do tipo java-gradle-plugin (normalmente chamado build-logic ou similar)
  2. No módulo, desenvolver os plugins em Kotlin, aplicando as configurações comuns como android, kotlin, dependências, lint etc.
  3. Publicar localmente para serem consumidos pelos demais módulos do projeto

Exemplo simplificado

No seu settings.gradle.kts:

include(":app", ":build-logic")

No módulo build-logic/build.gradle.kts:

plugins {
    `kotlin-dsl`
    `java-gradle-plugin`
}

gradlePlugin {
    plugins {
        create("androidConvention") {
            id = "com.example.android.convention"
            implementationClass = "com.example.buildlogic.AndroidConventionPlugin"
        }
    }
}

dependencies {
    implementation("com.android.tools.build:gradle:8.1.0")
    implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:1.9.0")
}

Implementação do plugin (build-logic/src/main/kotlin/.../AndroidConventionPlugin.kt):

package com.example.buildlogic

import com.android.build.gradle.ApplicationExtension
import org.gradle.api.Plugin
import org.gradle.api.Project
import org.gradle.kotlin.dsl.configure

class AndroidConventionPlugin : Plugin<Project> {
    override fun apply(project: Project) {
        project.plugins.apply("com.android.application")
        project.plugins.apply("org.jetbrains.kotlin.android")

        project.extensions.configure<ApplicationExtension> {
            compileSdkVersion(34)

            defaultConfig {
                minSdk = 21
                targetSdk = 34
                versionCode = 1
                versionName = "1.0"
            }

            buildTypes {
                getByName("release") {
                    isMinifyEnabled = true
                }
            }
        }
    }
}

Agora, no app/build.gradle.kts:

plugins {
    id("com.example.android.convention")
}

Com isso, o módulo app herda toda configuração padrão para Android e Kotlin Android, mantendo o build.gradle.kts limpo e fácil de manter.

Boas práticas e armadilhas comuns

Boas práticas

  • Isolar configurações comuns: versão do SDK, dependências de teste, opções de compilação
  • Manter plugins pequenos e focados: prefira criar múltiplos plugins para responsabilidades diferentes (ex: um para configuração Android, outro para Compose, outro para multiplataforma)
  • Versionar o módulo de plugins junto com o projeto para evitar desalinhamentos
  • Documentar os plugins e seu uso, para facilitar adoção pelos times

Armadilhas comuns

  • Excesso de magia: plugins muito complexos tornam difícil entender o build do projeto
  • Dependências cíclicas: cuidado ao estruturar módulos para que o plugin não dependa do módulo que o usa
  • Não usar Kotlin DSL: preferir Kotlin para maior segurança de tipo e autocomplete no código Gradle
  • Ignorar performance do Gradle: certifique-se de que o plugin não crie configurações lentas ou pesadas sem necessidade

Conclusão

Os convention plugins modernizam a forma como configuramos builds Android, trazendo organização, padronização e facilidade de manutenção para projetos cada vez maiores e mais complexos. Adotá-los facilita a vida do time e torna o processo de build mais sustentável a longo prazo.

Se você ainda não usa convenção via plugins, experimente criar uma configuração mínima para seus módulos e veja a diferença na produtividade e na clareza do seu projeto Android.

Desafie-se a aplicar essa técnica no seu próximo projeto e compartilhe suas experiências!

Happy coding! 🚀