Catálogos de Versões do Gradle no Android

Os catálogos de versão do Gradle nos permitem adicionar e manter dependências de uma forma fácil e escalável. Com o crescimento das aplicações e o gerenciamento de projetos com várias equipes de desenvolvimento, o tempo de compilação aumenta.

Uma possível solução para abordar esse problema envolve segmentar o projeto em múltiplos módulos. Compilar esses módulos em paralelo e recompilar apenas as partes modificadas reduz o tempo de compilação total. No entanto, surge uma dificuldade: como podemos compartilhar de forma eficaz as dependências de bibliotecas comuns e suas respectivas versões, evitando erros de compilação e a necessidade de analisar manualmente os arquivos Gradle em cada módulo para evitar problemas de sincronização?

Os catálogos de versão do Gradle nos ajudam a centralizar todas as dependências em um único arquivo com tipagem segura que você pode chamar de seus módulos.

Criar Arquivo de Versão

Primeiro, precisamos criar nosso arquivo na pasta Gradle. Por convenção, usamos o nome libs.version.toml, recomendado nas orientações de desenvolvimento Android.

Este arquivo terá três seções:

[versions]

[libraries]

[plugins]

• Versões. Define as versões das suas dependências e plugins que são usadas nos outros dois blocos
• Bibliotecas. Contém as dependências.
• Plugins. Contém os plugins.

Vamos definir, como exemplo, a versão e as dependências da biblioteca de Injeção de Dependências Koin.

[versions]
koin = "3.4.0"

[libraries]
koin-core = { group = "io.insert-koin", name = "koin-core", version.ref = "koin" }
koin-android = { group = "io.insert-koin", name = "koin-android", version.ref = "koin" }
koin-androidx-compose = { group = "io.insert-koin", name = "koin-androidx-compose", version.ref = "koin" }
koin-androidx-workmanager = { group = "io.insert-koin", name = "koin-androidx-workmanager", version.ref = "koin" }
koin-test = { group = "io.insert-koin", name = "koin-test", version.ref = "koin" }
koin-test-junit4 = { group = "io.insert-koin", name = "koin-test-junit4", version.ref = "koin" }

Então, para chamar a dependência de qualquer módulo, só precisaríamos fazer o seguinte:

Dependencies {
    implementation(libs.koin.core)
    implementation(libs.koin.android)
}

Crie Seus Plugins, e Todos Seus Módulos Sempre Estarão Sincronizados

Quando já tivermos nossas dependências migradas, percebemos um problema. Todos os nossos módulos que precisam de Koin terão que repetir as mesmas linhas. Aqui, podemos ver um exemplo claro de DRY (Don’t Repeat Yourself), e criaremos um plugin Gradle para nos poupar de repetir, repetidamente, a inclusão dessas dependências.

Em nosso arquivo build.gradle.kts, poderemos registrar nossos plugins Gradle.

gradlePlugin {
    plugins {
            register("koin") {
                    id = "example.android.koin"
                    implementationClass = "AndroidKoinConventionPlugin"
                }
}
}

Em seguida, criaremos nosso plugin e adicionaremos as dependências deste plugin com GVC.

class AndroidKoinConventionPlugin : Plugin<Project> {
    override fun apply(target: Project) {
        with(target) {
            val libs = extensions.getByType<VersionCatalogsExtension>().named("libs")
            dependencies {
      "implementation"(libs.findLibrary("koin.core").get())
      "implementation"(libs.findLibrary("koin.android").get())
      "implementation"(libs.findLibrary("koin.androidx.compose").get())
      "implementation"(libs.findLibrary("koin.androidx.workmanager").get())
      "testImplementation"(libs.findLibrary("koin.test").get())
      "testImplementation"(libs.findLibrary("koin.test.junit4").get())
            }
        }
    }
}

A única coisa que resta é chamar no nosso módulo o plugin Koin, e se algum dia tivermos que atualizar a versão, só precisaremos ir ao nosso arquivo de definições, e todos eles serão atualizados ao sincronizar o Gradle. Por exemplo, o arquivo do módulo de dados com todas as suas dependências

plugins {
    id("example.android.library")
    id("example.android.koin")
}

android {
    namespace = "com.example.core.data"
}

dependencies {
    implementation(libs.kotlinx.coroutines.android)
}

Com tudo isso, podemos criar plugins que agrupam dependências, por exemplo:

• Biblioteca
• Compose
• Sabores
• Recurso
• DI
• Banco de Dados
• Teste

Considerações

Os catálogos de versões do Gradle ainda estão em pleno desenvolvimento, e é bom acompanhar os bugs e limitações conhecidos que o Android está publicando. Os exemplos deste artigo demonstram os benefícios dos catálogos de versões do Gradle e como eles podem facilitar nossas vidas. Se você está procurando uma aplicação funcional disso, pode ver isso no GitHub agora para Android.