Cataloghi delle Versioni di Gradle su Android

I cataloghi delle versioni di Gradle ci consentono di aggiungere e gestire le dipendenze in modo semplice e scalabile. Gli app crescono e la gestione dei progetti con diverse squadre di sviluppo aumenta il tempo di compilazione.

Una possibile soluzione per affrontare questo problema consiste nel segmentare il progetto in più moduli. Compilare questi moduli in parallelo e ricompilare solo le parti modificate riduce il tempo complessivo di compilazione. Tuttavia, sorge un dilemma: come possiamo condividere in modo efficace le dipendenze delle librerie comuni e le loro relative versioni evitando errori di compilazione e la necessità di esaminare manualmente i file Gradle in ciascun modulo per prevenire problemi di sincronizzazione?

I cataloghi delle versioni di Gradle ci aiutano a centralizzare tutte le dipendenze in un unico file con tipizzazione sicura che puoi richiamare dai tuoi moduli.

Crea il File delle Versioni

Per prima cosa, dobbiamo creare il nostro file nella cartella Gradle. Per convenzione, utilizziamo il nome libs.version.toml raccomandato nei guide di sviluppo Android.

Questo file avrà tre sezioni:

[versions]

[libraries]

[plugins]

• Versioni. Definisce le versioni delle tue dipendenze e plugin utilizzati negli altri due blocchi
• Librerie. Contiene le dipendenze.
• Plugin. Contiene i plugin.

Definiamo ad esempio la versione e le dipendenze della libreria di Iniezione di Dipendenze 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" }

Quindi, per richiamare la dipendenza da qualsiasi modulo, dovremmo solo fare quanto segue:

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

Crea i tuoi Plugin, e Tutti i Tuoi Moduli Saranno Sempre Sincronizzati

Quando abbiamo già migrato le nostre dipendenze, riscontriamo un problema. Tutti i nostri moduli che necessitano di Koin dovranno ripetere le stesse righe. Qui, possiamo vedere un chiaro esempio di DRY (Don’t Repeat Yourself), e creeremo un plugin Gradle per risparmiare dalla ripetizione continua dell’inclusione di queste dipendenze.

Nel nostro file build.gradle.kts, saremo in grado di registrare i nostri plugin Gradle.

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

Successivamente, creeremo il nostro plugin e aggiungeremo le dipendenze di questo 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())
            }
        }
    }
}

L’unica cosa che rimane è richiamare nei nostri moduli il plugin Koin, e se un giorno dobbiamo aggiornare la versione, dobbiamo solo andare nel nostro file di definizioni, e tutti saranno aggiornati al sincronizzare Gradle. Ad esempio, il file del modulo dati con tutte le sue dipendenze

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

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

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

Con tutto ciò, possiamo creare plugin che raggruppano dipendenze, per esempio:

• Libreria
• Compose
• Varianti
• Funzionalità
• DI
• Database
• Test

Considerazioni

I catalogi delle versioni di Gradle sono ancora in pieno sviluppo, pertanto è bene tenere d’occhio i bug e le limitazioni noti che Android sta pubblicando. Gli esempi in questo articolo illustrano i vantaggi dei cataloghi delle versioni di Gradle e come possono semplificare la nostra vita. Se cerchi un’applicazione funzionale, puoi verificarla su GitHub ora per Android.