Gradle Versiecatalogi op Android

Gradle versiecatalogi stellen ons in staat afhankelijkheden op een gemakkelijke en schaalbare manier toe te voegen en te onderhouden. Apps groeien en het beheren van projecten met meerdere ontwikkelingsteams verhoogt de compilatietijd.

Een mogelijke oplossing om dit probleem aan te pakken, houdt in dat het project in meerdere modules wordt gesegmenteerd. Het compileren van deze modules parallel en alleen de gewijzigde delen opnieuw compileren, vermindert de totale compilatietijd. Echter, doet zich een probleem voor: Hoe kunnen we effectief gemeenschappelijke bibliotheekafhankelijkheden en hun respectievelijke versies delen, terwijl we compilatiefouten vermijden en de noodzaak om handmatig Gradle-bestanden in elke module te onderzoeken om synchronisatieproblemen te voorkomen?

Gradle versiecatalogi helpen ons om alle afhankelijkheden in een enkel bestand te centraliseren met veilige typen die je vanuit je modules kunt aanroepen.

Maak Versiebestand

Eerst moeten we ons bestand in de Gradle-map maken. Volgens afspraak gebruiken we de naam libs.version.toml die wordt aanbevolen in de richtlijnen voor Android-ontwikkeling.

Dit bestand zal drie secties bevatten:

[versions]

[libraries]

[plugins]

• Versies. Het definieert de versies van uw afhankelijkheden en plugins die worden gebruikt in de andere twee blokken
• Bibliotheken. Bevat de afhankelijkheden.
• Plugins. Bevat de plugins.

Laten we als voorbeeld de versie en afhankelijkheden van de Koin Dependency Injection-bibliotheek definiëren.

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

Vervolgens, om de afhankelijkheid vanuit elke module aan te roepen, zouden we alleen het volgende moeten doen:

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

Maak uw plugins, en al uw modules zullen altijd gesynchroniseerd zijn

Wanneer we al onze afhankelijkheden gemigreerd hebben, zien we een probleem. Al onze modules die Koin nodig hebben, zullen dezelfde regels moeten herhalen. Hier zien we een duidelijk voorbeeld van DRY (Don’t Repeat Yourself), en we zullen een Gradle-plugin maken om ons te ontzien van het steeds herhalen van deze afhankelijkheden.

In ons build.gradle.kts bestand kunnen we onze Gradle-plugins registreren.

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

Vervolgens zullen we onze plugin maken en de afhankelijkheden van deze plugin toevoegen met 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())
            }
        }
    }
}

Het enige wat overblijft is de Koin-plugin in onze modules aan te roepen, en als we ooit de versie moeten bijwerken, hoeven we alleen naar ons definitiesbestand te gaan, en ze zullen allemaal worden bijgewerkt bij het synchroniseren van Gradle. Bijvoorbeeld, het data-modulebestand met al zijn afhankelijkheden

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

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

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

Met dit alles kunnen we plugins maken die afhankelijkheden groeperen, zoals:

• Bibliotheek
• Compose
• Smaken
• Functie
• DI
• Database
• Test

Overwegingen

Gradle-versiecatalogi zijn nog steeds in volle ontwikkeling en het is goed om de bekende fouten en beperkingen te volgen die Android publiceert. De voorbeelden in dit artikel laten zien hoe Gradle-versiecatalogi onze levens kunnen vergemakkelijken en welke voordelen ze bieden. Als je op zoek bent naar een functioneel toepassingsvoorbeeld, kun je het nu op GitHub voor Android bekijken.