Gradle-Versionskataloge in Android

Gradle-Versionskataloge ermöglichen es uns, Abhängigkeiten auf einfache und skalierbare Weise hinzuzufügen und zu pflegen. Apps wachsen, und das Verwalten von Projekten mit mehreren Entwicklungsteams erhöht die Kompilierungszeit.

Eine mögliche Lösung zur Behebung dieses Problems besteht darin, das Projekt in mehrere Module aufzuteilen. Die parallele Kompilierung dieser Module und lediglich die erneute Kompilierung der geänderten Bereiche reduziert die gesamte Kompilierungszeit. Es ergibt sich jedoch ein Dilemma: Wie können wir gemeinsame Bibliotheksabhängigkeiten und deren entsprechende Versionen effektiv teilen, ohne Kompilierungsfehler zu provozieren und ohne die Gradle-Dateien in jedem Modul manuell zu überprüfen, um Synchronisationsprobleme zu vermeiden?

Gradle-Versionskataloge helfen uns, alle Abhängigkeiten in einer einzigen Datei mit sicheren Typen zu konzentrieren, die Sie von Ihren Modulen aus aufrufen können.

Version-Datei erstellen

Zuerst müssen wir unsere Datei im Gradle-Ordner erstellen. Konventionell verwenden wir den Namen libs.version.toml, wie es in den Android-Entwicklungsrichtlinien empfohlen wird.

Diese Datei wird in drei Abschnitte unterteilt:

[versions]

[libraries]

[plugins]

• Versionen. Es definiert die Versionen Ihrer Abhängigkeiten und Plugins, die in den anderen beiden Blöcken verwendet werden
• Bibliotheken. Enthält die Abhängigkeiten.
• Plugins. Enthält die Plugins.

Definieren wir als Beispiel die Version und Abhängigkeiten der Koin-Dependency-Injection-Bibliothek.

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

Um dann die Abhängigkeit von jedem Modul aus aufzurufen, müssten wir nur Folgendes tun:

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

Erstellen Sie Ihre Plugins, und alle Ihre Module werden immer synchron sein

Sobald wir unsere Abhängigkeiten migriert haben, stoßen wir auf ein Problem. Alle unsere Module, die Koin benötigen, müssen die gleichen Zeilen wiederholen. Hier sehen wir ein klares Beispiel für DRY (Don’t Repeat Yourself), und wir werden ein Gradle-Plugin erstellen, um uns vor der wiederholten Einbindung dieser Abhängigkeiten zu bewahren.

In unserem build.gradle.kts-Datei können wir unsere Gradle-Plugins registrieren.

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

Dann erstellen wir unser Plugin und fügen die Abhängigkeiten dieses Plugins mit GVC hinzu.

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())
            }
        }
    }
}

Das einzige, was noch übrig ist, ist das Aufrufen des Koin-Plugins in unseren Modulen, und wenn wir eines Tages die Version aktualisieren müssen, müssen wir nur zu unserer Definitionsdatei gehen, und alle werden bei der Synchronisierung von Gradle aktualisiert. Zum Beispiel die Datenmoduldatei mit allen ihren Abhängigkeiten

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

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

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

Mit all dem können wir Plugins erstellen, die Abhängigkeiten gruppieren, zum Beispiel:

• Bibliothek
• Compose
• Aromen
• Funktion
• DI
• Datenbank
• Test

Überlegungen

Gradle-Versionskataloge befinden sich noch in voller Entwicklung, und es ist gut, die bekannten Fehler und Einschränkungen zu beobachten, die Android veröffentlicht. Die Beispiele in diesem Artikel zeigen die Vorteile von Gradle-Versionskatalogen und wie sie unser Leben erleichtern können. Wenn Sie nach einer funktionalen Anwendung suchen, können Sie sie jetzt auf GitHub für Android ansehen.