Catálogos de versiones de Gradle en Android

Introducción: Catálogos de versiones de Gradle

Los catálogos de versiones de Gradle nos permiten añadir y mantener dependencias de forma sencilla y escalable. Las apps crecen, y gestionar proyectos con varios equipos de desarrollo aumenta el tiempo de compilación.

Una posible solución consiste en segmentar el proyecto en varios módulos. Compilar estos módulos en paralelo y recompilar únicamente las partes modificadas reduce el tiempo total de compilación. Sin embargo, surge un predicamento: ¿cómo podemos compartir eficazmente las dependencias de bibliotecas comunes y sus respectivas versiones, evitando al mismo tiempo los errores de compilación y la necesidad de examinar manualmente los archivos de Gradle en cada módulo para evitar problemas de sincronización?

Los catálogos de versiones de Gradle nos ayudan a centralizar todas las dependencias en un único archivo con tipado seguro que puedes llamar desde tus módulos.

Crear archivo de versión

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

Este archivo tendrá tres secciones:

[versions]

[libraries]

[plugins]

• Versiones. Define las versiones de sus 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 librería Koin Dependency Injection.

[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" }

Entonces para llamar a la dependencia desde cualquier módulo sólo tendríamos que hacer:

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

Crea tus plugins y todos tus módulos estarán siempre sincronizados

Cuando ya tenemos nuestras dependencias migradas, vemos un problema. Todos nuestros módulos que necesiten 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 ahorrarnos repetir, una y otra vez, la inclusión de estas dependencias.

En nuestro fichero build.gradle.kts podremos registrar nuestros plugins gradle

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

Luego crearemos nuestro plugin donde 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 nos queda es llamar en nuestros módulos al plugin Koin, y si algún día, tenemos que actualizar la versión, sólo tenemos que ir a nuestro fichero de definiciones, y todas ellas se actualizarán al sincronizar gradle. Por ejemplo, el fichero 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
• Flavors
• Feature
• DI
• Database
• Pruebas

Consideraciones

Los catálogos de versiones de Gradle están todavía en pleno desarrollo, y es bueno seguir los errores conocidos y las limitaciones que Android va publicando. Los ejemplos de este artículo muestran las ventajas de los catálogos de versiones de Gradle y cómo pueden hacernos la vida más fácil. Si estás buscando una aplicación funcional del mismo, puedes verla en GitHub now para Android.

¿Te interesa leer más sobre desarrollo Android? Te sugiero que visites el blog de Apiumhub para estar al día de las últimas tecnologías. Cada semana se publican nuevos y apasionantes contenidos sobre desarrollo Android, arquitectura de software, desarrollo frontend, desarrollo backend y mucho más.