Android Plataforma - Parte 6: Version Catalog

🌱 Branch: 6/version-catalog

🔗 Repositório: github.com/rsicarelli/kotlin-gradle-android-platform

⬅️ Artigo Anterior: Parte 5: Simplificando Gradle Init

➡️ Próximo Artigo: Parte 7: Decorando o módulo 'app'

---

No post anterior, otimizamos nossa plataforma, deixando-a preparada para mais funcionalidades.

Neste post, vamos configurar os Version Catalogs do Gradle, proporcionando uma forma sofisticada de gerenciar nossas dependências.

---

O que são Version Catalogs?

Version Catalogs é uma funcionalidade lançada inicialmente como experimental no Gradle 7.x e posteriormente estabilizada na versão 8.x.

Essencialmente, esse recurso gera um "acessor de projeto", frequentemente nomeado como libs. Ele pode ser definido através de uma DSL no settings.gradle.kts ou por meio de um arquivo .toml. Neste tutorial, optaremos pela abordagem do arquivo .toml.

Passos

1 - Acesse a pasta gradle no diretório raiz do seu projeto e crie um arquivo nomeado libs.versions.toml:

cd gradle
touch libs.versions.toml

2 - Edite o arquivo libs.versions.toml e defina as dependências do projeto:

[versions]
composeBom = "2023.09.01"
composeKotlinCompilerExtension = "1.5.3"
androidxCoreKtx = "1.12.0"
androidxLifecycleRuntimeKtx = "2.6.2"
androidxComposeActivity = "1.7.2"
androidBuildTools = "8.1.1"
kotlin = "1.9.10"

[libraries]
androidx-compose-bom = { module = "androidx.compose:compose-bom", version.ref = "composeBom" }
androidx-compose-ui = { module = "androidx.compose.ui:ui" }
androidx-compose-ui-graphics = { module = "androidx.compose.ui:ui-graphics" }
androidx-compose-ui-tooling-preview = { module = "androidx.compose.ui:ui-tooling-preview" }
androidx-compose-material3 = { module = "androidx.compose.material3:material3" }
androidx-compose-ui-tooling = { module = "androidx.compose.ui:ui-tooling" }
androidx-compose-ui-test-manifest = { module = "androidx.compose.ui:ui-test-manifest" }
androidx-core-ktx = { module = "androidx.core:core-ktx", version.ref = "androidxCoreKtx" }
androidx-lifecycle-runtime-ktx = { module = "androidx.lifecycle:lifecycle-runtime-ktx", version.ref = "androidxLifecycleRuntimeKtx" }
androidx-activity-compose = { module = "androidx.activity:activity-compose", version.ref = "androidxComposeActivity" }

[plugins]
android-application = { id = "com.android.application", version.ref = "androidBuildTools" }
android-library = { id = "com.android.library", version.ref = "androidBuildTools" }
kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
rsicarelli-kplatform = { id = "com.rsicarelli.kplatform" }

3 - Vá até o arquivo build-logic > settings.gradle.kts e integre o nosso libs.versions.toml:

// build-logic/settings.gradle.kts

..

dependencyResolutionManagement {
    ..
    versionCatalogs {
        create("libs") {
            // Note que subimos 1 nível de folder, para utilizar a pasta "gradle" da raiz 
            from(files("../gradle/libs.versions.toml"))
        }
    }
}

Notas Importantes:

1. É vital que o libs.versions.toml esteja localizado na pasta gradle do diretório raiz. Isso garante que tanto o projeto quanto nosso build-logic possam acessar esse catálogo.
2. A adição do version catalog no build-logic > settings.gradle.kts assegura que o catálogo seja incluído tanto no projeto quanto no build-logic.

Mantenha essas observações em mente, pois podem evitar futuros problemas relacionados à localização dos arquivos.

Utilizando o acessor de projeto libs

Após sincronizar o projeto, uma nova classe libs estará disponível. Agora, é hora de atualizar todos os build.gradle.kts para fazer uso desta classe:

// build.gradle.kts da raiz

plugins {
    alias(libs.plugins.android.application) apply false
    alias(libs.plugins.kotlin.android) apply false
    id(libs.plugins.rsicarelli.kplatform.get().pluginId)
}

// app/build.gradle.kts

plugins {
    id(libs.plugins.android.application.get().pluginId)
    kotlin("android")
}
..

dependencies {
    implementation(libs.androidx.core.ktx)
    implementation(libs.androidx.lifecycle.runtime.ktx)
    implementation(libs.androidx.activity.compose)
    implementation(projects.core.designsystem)
    implementation(projects.features.home)
}

// core/designsystem/build.gradle.kts

plugins {
    id(libs.plugins.android.library.get().pluginId)
    kotlin("android")
}
..

dependencies {
    implementation(platform(libs.androidx.compose.bom))
    api(libs.androidx.compose.ui)
    api(libs.androidx.compose.ui.graphics)
    api(libs.androidx.compose.ui.tooling.preview)
    api(libs.androidx.compose.material3)
    debugApi(libs.androidx.compose.ui.tooling)
    debugApi(libs.androidx.compose.ui.test.manifest)
}

// feature/details/build.gradle.kts
// feature/home/build.gradle.kts

plugins {
    id(libs.plugins.android.library.get().pluginId)
    kotlin("android")
}
..

Atualizando a versão do Compose Compiler

Busque por referências do kotlinCompilerExtensionVersion e substitua pelo nosso acessor libs:

composeOptions {
    kotlinCompilerExtensionVersion = libs.versions.composeKotlinCompilerExtension.get()
}

Concluído!

Com essas alterações, agora possuímos uma maneira robusta e unificada de gerenciar nossas dependências, seja no projeto ou na plataforma.

No próximo artigo, migraremos nossos scripts do módulo app diretamente para nossa plataforma.