Catálogos de Versiones de Gradle en Android

Las bibliotecas de versiones de Gradle permiten agregar y mantener dependencias de una manera fácil y escalable. Las aplicaciones crecen, y gestionar proyectos con varias equipos de desarrollo aumenta el tiempo de compilación.

Una solución potencial para abordar este problema implica segmentar el proyecto en múltiples módulos. Compilar estos módulos en paralelo y recompilar solo las porciones modificadas reduce el tiempo de compilación general. Sin embargo, surge una situación problemática: ¿Cómo podemos compartir de manera efectiva las dependencias de bibliotecas comunes y sus versiones respectivas mientras evitamos errores de compilación y la necesidad de revisar manualmente los archivos de Gradle en cada módulo para prevenir problemas de sincronización?

Las bibliotecas de versiones de Gradle nos ayudan a centralizar todas las dependencias en un solo archivo con tipado seguro que puedes llamar desde tus módulos.

Crear Archivo de Versiones

Primero, tenemos que crear nuestro archivo en la carpeta de Gradle. Por convención, usamos el nombre libs.version.toml recomendado en las guías de desarrollo de Android.

Este archivo tendrá tres secciones:

[versions]

[libraries]

[plugins]

• Versiones. Define las versiones de tus dependencias y plugins que se utilizan en los otros dos bloques
• Bibliotecas. Contiene las dependencias.
• Plugins. Contiene los plugins.

Definamos, como ejemplo, la versión y las dependencias de la biblioteca de Injección de Dependencias 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" }

Luego, para llamar a la dependencia desde cualquier módulo, solo tendríamos que hacer lo siguiente:

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

Crea Tus Plugins, y Todos Tus Módulos Estarán Siempre Sincronizados

Cuando ya hemos migrado nuestras dependencias, encontramos un problema. Todos nuestros módulos que necesitan Koin tendrán que repetir las mismas líneas. Aquí, podemos ver un claro ejemplo de DRY (Don’t Repeat Yourself), y crearemos un plugin de Gradle para librarnos de repetir, una y otra vez, la inclusión de estas dependencias.

En nuestro archivo build.gradle.kts, podremos registrar nuestros plugins de gradle.

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

Luego, crearemos nuestro plugin y añadiremos las dependencias de este plugin con 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())
            }
        }
    }
}

Lo único que queda es llamar en nuestros módulos al plugin de Koin, y si algún día tenemos que actualizar la versión, solo tendremos que ir a nuestro archivo de definiciones, y todas ellas se actualizarán al sincronizar Gradle. Por ejemplo, el archivo del módulo de datos con todas sus dependencias

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

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

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

Con todo esto, podemos crear plugins que agrupen dependencias, por ejemplo:

• Biblioteca
• Compose
• Sabores
• Característica
• DI
• Base de datos
• Prueba

Consideraciones

Las bibliotecas de versiones de Gradle siguen en pleno desarrollo, por lo que es bueno estar al tanto de los errores conocidos y limitaciones que Android está publicando. Los ejemplos de este artículo ilustran los beneficios de las bibliotecas de versiones de Gradle y cómo pueden facilitar nuestras vidas. Si buscas una aplicación funcional de ello, puedes verla en GitHub ahora para Android.