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 maneira 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 solução potencial para enfrentar 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 um dilema: 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 no diretório do 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 utilizados 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ência 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 Estarão Sempre Sincronizados

Quando já temos nossas dependências migradas, percebemos um problema. Todos os nossos módulos que precisam do Koin terão que repetir as mesmas linhas. Aqui, podemos ver um exemplo claro do DRY (Don’t Repeat Yourself), e vamos criar um plugin Gradle para nos poupar de repetir, vez após vez, 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 em nossos módulos 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 neste 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.