Android KTX   Teil von Android Jetpack.

Android KTX ist eine Reihe von Kotlin-Erweiterungen, die in Android Jetpack und anderen Android-Bibliotheken enthalten sind. KTX-Erweiterungen bieten prägnante, idiomatische Kotlin-Funktionen für Jetpack, die Android-Plattform und andere APIs. Dazu nutzen diese Erweiterungen mehrere Kotlin-Sprachfunktionen, darunter:

  • Erweiterungsfunktionen
  • Erweiterungseigenschaften
  • Lambdas
  • Benannte Parameter
  • Standardwerte für Parameter
  • Koroutinen

Wenn Sie beispielsweise mit SharedPreferences arbeiten, müssen Sie zuerst einen Editor erstellen, bevor Sie Änderungen an den Einstellungsdaten vornehmen können. Sie müssen diese Änderungen auch anwenden oder bestätigen, wenn Sie mit der Bearbeitung fertig sind, wie im folgenden Beispiel gezeigt:

sharedPreferences
        .edit()  // create an Editor
        .putBoolean("key", value)
        .apply() // write to disk asynchronously

Kotlin-Lambdas eignen sich perfekt für diesen Anwendungsfall. Sie können einen prägnanteren Ansatz wählen, indem Sie einen Codeblock übergeben, der nach dem Erstellen des Editors ausgeführt wird. Lassen Sie den Code dann ausführen und wenden Sie die Änderungen dann atomar mit der SharedPreferences API an.

Hier ist ein Beispiel für eine der Android-KTX-Core-Funktionen, SharedPreferences.edit, die SharedPreferences eine Bearbeitungsfunktion hinzufügt. Diese Funktion nimmt ein optionales boolean-Flag als erstes Argument an, das angibt, ob die Änderungen committet oder angewendet werden sollen. Außerdem erhält es eine Aktion, die im SharedPreferences-Editor ausgeführt werden soll, in Form eines Lambda-Ausdrucks.

// SharedPreferences.edit extension function signature from Android KTX - Core
// inline fun SharedPreferences.edit(
//         commit: Boolean = false,
//         action: SharedPreferences.Editor.() -> Unit)

// Commit a new value asynchronously
sharedPreferences.edit { putBoolean("key", value) }

// Commit a new value synchronously
sharedPreferences.edit(commit = true) { putBoolean("key", value) }

Der Aufrufer kann auswählen, ob die Änderungen übernommen oder angewendet werden sollen. Das action-Lambda ist selbst eine anonyme Erweiterungsfunktion von SharedPreferences.Editor, die Unit zurückgibt, wie aus der Signatur hervorgeht. Deshalb können Sie die Arbeit innerhalb des Blocks direkt auf der SharedPreferences.Editor ausführen.

Schließlich enthält die SharedPreferences.edit()-Signatur das Schlüsselwort inline. Dieses Keyword weist den Kotlin-Compiler an, den kompilierten Bytecode für die Funktion jedes Mal zu kopieren und einzufügen (oder inline einzufügen), wenn die Funktion verwendet wird. So wird der Overhead vermieden, der beim Instanziieren einer neuen Klasse für jede action jedes Mal auftritt, wenn diese Funktion aufgerufen wird.

Dieses Muster, Code mithilfe von Lambdas zu übergeben, sinnvolle Standardeinstellungen anzuwenden, die überschrieben werden können, und diese Verhaltensweisen mithilfe von inline-Erweiterungsfunktionen zu vorhandenen APIs hinzuzufügen, ist typisch für die Verbesserungen, die die Android KTX-Bibliothek bietet.

Android KTX in Ihrem Projekt verwenden

Wenn Sie Android KTX verwenden möchten, fügen Sie der build.gradle-Datei Ihres Projekts die folgende Abhängigkeit hinzu:

Groovy

repositories {
    google()
}

Kotlin

repositories {
    google()
}

AndroidX-Module

Android KTX ist in Module unterteilt, die jeweils ein oder mehrere Pakete enthalten.

Sie müssen in der build.gradle-Datei Ihrer Anwendung eine Abhängigkeit für jedes Modul-Artefakt angeben. Hängen Sie dem Artefakt die Versionsnummer an. Die neuesten Versionsnummern finden Sie in diesem Thema im entsprechenden Abschnitt für jedes Artefakt.

Android KTX enthält ein einziges Kernmodul, das Kotlin-Erweiterungen für gängige Framework-APIs und mehrere domänenspezifische Erweiterungen bietet.

Mit Ausnahme des Kernmoduls ersetzen alle KTX-Modulartefakte die zugrunde liegende Java-Abhängigkeit in Ihrer build.gradle-Datei. Sie können beispielsweise eine androidx.fragment:fragment-Abhängigkeit durch androidx.fragment:fragment-ktx ersetzen. Diese Syntax trägt zu einer besseren Versionsverwaltung bei und erfordert keine zusätzlichen Anforderungen an die Abhängigkeitsdeklaration.

Core KTX

Das Core-KTX-Modul bietet Erweiterungen für gängige Bibliotheken, die Teil des Android-Frameworks sind. Diese Bibliotheken haben keine Java-basierten Abhängigkeiten, die Sie build.gradle hinzufügen müssen.

Dazu fügen Sie der Datei build.gradle Ihrer App Folgendes hinzu:

Groovy

dependencies {
    implementation "androidx.core:core-ktx:1.15.0"
}

Kotlin

dependencies {
    implementation("androidx.core:core-ktx:1.15.0")
}

Hier finden Sie eine Liste der Pakete, die im Core-KTX-Modul enthalten sind:

Collection KTX

Die Sammlungserweiterungen enthalten Dienstprogrammfunktionen für die Arbeit mit den speichereffizienten Sammlungsbibliotheken von Android, darunter ArrayMap, LongSparseArray und LruCache.

Wenn Sie dieses Modul verwenden möchten, fügen Sie der Datei build.gradle Ihrer App Folgendes hinzu:

Groovy

dependencies {
    implementation "androidx.collection:collection-ktx:1.4.5"
}

Kotlin

dependencies {
    implementation("androidx.collection:collection-ktx:1.4.5")
}

Sammlungserweiterungen nutzen die Operatorüberladung von Kotlin, um beispielsweise die Sammlungskonkatenierung zu vereinfachen, wie im folgenden Beispiel gezeigt:

// Combine 2 ArraySets into 1.
val combinedArraySet = arraySetOf(1, 2, 3) + arraySetOf(4, 5, 6)

// Combine with numbers to create a new sets.
val newArraySet = combinedArraySet + 7 + 8

Fragment KTX

Das Fragment-KTX-Modul bietet eine Reihe von Erweiterungen, um die Fragment-API zu vereinfachen.

Dazu fügen Sie der Datei build.gradle Ihrer App Folgendes hinzu:

Cool

dependencies {
    implementation "androidx.fragment:fragment-ktx:1.8.3"
}

Kotlin

dependencies {
    implementation("androidx.fragment:fragment-ktx:1.8.3")
}

Mit dem Fragment-KTX-Modul können Sie Fragmenttransaktionen mithilfe von Lambdas vereinfachen, z. B.:

fragmentManager().commit {
   addToBackStack("...")
   setCustomAnimations(
           R.anim.enter_anim,
           R.anim.exit_anim)
   add(fragment, "...")
}

Sie können auch mithilfe der Property-Delegierten viewModels und activityViewModels in einer Zeile an eine ViewModel binden:

// Get a reference to the ViewModel scoped to this Fragment
val viewModel by viewModels<MyViewModel>()

// Get a reference to the ViewModel scoped to its Activity
val viewModel by activityViewModels<MyViewModel>()

Lifecycle KTX

In Lifecycle-KTX wird für jedes Lifecycle-Objekt ein LifecycleScope definiert. Alle in diesem Gültigkeitsbereich gestarteten coroutines werden abgebrochen, wenn Lifecycle zerstört wird. Sie können über die Properties lifecycle.coroutineScope oder lifecycleOwner.lifecycleScope auf die CoroutineScope von Lifecycle zugreifen.

Dazu fügen Sie der Datei build.gradle Ihrer App Folgendes hinzu:

Groovy

dependencies {
    implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.8.7"
}

Kotlin

dependencies {
    implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.8.7")
}

Das folgende Beispiel zeigt, wie Sie mit lifecycleOwner.lifecycleScope vorab berechneten Text asynchron erstellen:

class MyFragment: Fragment() {
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        viewLifecycleOwner.lifecycleScope.launch {
            val params = TextViewCompat.getTextMetricsParams(textView)
            val precomputedText = withContext(Dispatchers.Default) {
                PrecomputedTextCompat.create(longTextContent, params)
            }
            TextViewCompat.setPrecomputedText(textView, precomputedText)
        }
    }
}

LiveData KTX

Wenn Sie LiveData verwenden, müssen Sie Werte möglicherweise asynchron berechnen. Sie können beispielsweise die Einstellungen eines Nutzers abrufen und in Ihrer Benutzeroberfläche anzeigen lassen. In diesen Fällen bietet LiveData KTX eine liveData-Builderfunktion, die eine suspend-Funktion aufruft und das Ergebnis als LiveData-Objekt bereitstellt.

Dazu fügen Sie der Datei build.gradle Ihrer App Folgendes hinzu:

Groovy

dependencies {
    implementation "androidx.lifecycle:lifecycle-livedata-ktx:2.8.7"
}

Kotlin

dependencies {
    implementation("androidx.lifecycle:lifecycle-livedata-ktx:2.8.7")
}

Im folgenden Beispiel ist loadUser() eine anderweitig deklarierte Suspend-Funktion. Du kannst die Builder-Funktion liveData verwenden, um loadUser() asynchron aufzurufen, und dann emit() verwenden, um das Ergebnis auszugeben:

val user: LiveData<User> = liveData {
    val data = database.loadUser() // loadUser is a suspend function.
    emit(data)
}

Weitere Informationen zur Verwendung von Coroutinen mit LiveData finden Sie unter Kotlin-Coroutinen mit Architekturkomponenten verwenden.

Jede Komponente der Navigationsbibliothek hat eine eigene KTX-Version, die die API prägnanter und kotlin-idiomatisch anpasst.

Fügen Sie der Datei build.gradle Ihrer App Folgendes hinzu, um diese Module einzubinden:

Groovy

dependencies {
    implementation "androidx.navigation:navigation-runtime-ktx:2.8.5"
    implementation "androidx.navigation:navigation-fragment-ktx:2.8.5"
    implementation "androidx.navigation:navigation-ui-ktx:2.8.5"
}

Kotlin

dependencies {
    implementation("androidx.navigation:navigation-runtime-ktx:2.8.5")
    implementation("androidx.navigation:navigation-fragment-ktx:2.8.5")
    implementation("androidx.navigation:navigation-ui-ktx:2.8.5")
}

Verwenden Sie die Erweiterungsfunktionen und die Property-Delegierung, um auf Zielargumente zuzugreifen und zu Zielen zu wechseln, wie im folgenden Beispiel gezeigt:

class MyDestination : Fragment() {

    // Type-safe arguments are accessed from the bundle.
    val args by navArgs<MyDestinationArgs>()

    ...
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        view.findViewById<Button>(R.id.next)
            .setOnClickListener {
                // Fragment extension added to retrieve a NavController from
                // any destination.
                findNavController().navigate(R.id.action_to_next_destination)
            }
     }
     ...

}

Palette KTX

Das Palette KTX-Modul bietet idiomatische Kotlin-Unterstützung für die Arbeit mit Farbpaletten.

Wenn Sie dieses Modul verwenden möchten, fügen Sie der Datei build.gradle Ihrer App Folgendes hinzu:

Cool

dependencies {
    implementation "androidx.palette:palette-ktx:1.0.0"
}

Kotlin

dependencies {
    implementation("androidx.palette:palette-ktx:1.0.0")
}

Wenn Sie beispielsweise mit einer Palette-Instanz arbeiten, können Sie mit dem Get-Operator ([ ]) das selected-Swatch für eine bestimmte target abrufen:

val palette = Palette.from(bitmap).generate()
val swatch = palette[target]

Reactive Streams KTX

Mit dem KTX-Modul für Reactive Streams können Sie einen observable LiveData-Stream von einem ReactiveStreams-Publisher erstellen.

Dazu fügen Sie der Datei build.gradle Ihrer App Folgendes hinzu:

Groovy

dependencies {
    implementation "androidx.lifecycle:lifecycle-reactivestreams-ktx:2.8.7"
}

Kotlin

dependencies {
    implementation("androidx.lifecycle:lifecycle-reactivestreams-ktx:2.8.7")
}

Angenommen, Sie haben eine Datenbank mit einer kleinen Liste von Nutzern. In Ihrer App laden Sie die Datenbank in den Arbeitsspeicher und zeigen dann Nutzerdaten in Ihrer Benutzeroberfläche an. Dazu können Sie RxJava verwenden. Die Jetpack-Komponente Room kann die Nutzerliste als Flowable abrufen. In diesem Fall müssen Sie auch das Rx-Publisher-Abo während der gesamten Lebensdauer Ihres Fragments oder Ihrer Aktivität verwalten.

Mit LiveDataReactiveStreams können Sie jedoch von RxJava und seinen zahlreichen Operatoren und Funktionen zur Arbeitsplanung profitieren und gleichzeitig die Einfachheit von LiveData nutzen, wie im folgenden Beispiel gezeigt:

val fun getUsersLiveData() : LiveData<List<User>> {
    val users: Flowable<List<User>> = dao.findUsers()
    return LiveDataReactiveStreams.fromPublisher(users)
}

Raum KTX

Mit Room-Erweiterungen wird die Unterstützung von coroutines für Datenbanktransaktionen hinzugefügt.

Wenn Sie dieses Modul verwenden möchten, fügen Sie der Datei build.gradle Ihrer App Folgendes hinzu:

Groovy

dependencies {
    implementation "androidx.room:room-ktx:2.6.1"
}

Kotlin

dependencies {
    implementation("androidx.room:room-ktx:2.6.1")
}

Hier sind einige Beispiele, in denen Room jetzt coroutines verwendet. Im ersten Beispiel wird eine suspend-Funktion verwendet, um eine Liste von User-Objekten zurückzugeben. Im zweiten Beispiel wird die Flow-Funktion von Kotlin verwendet, um die User-Liste asynchron zurückzugeben. Wenn Sie Flow verwenden, werden Sie auch über Änderungen an den Tabellen informiert, die Sie abfragen.

@Query("SELECT * FROM Users")
suspend fun getUsers(): List<User>

@Query("SELECT * FROM Users")
fun getUsers(): Flow<List<User>>

SQLite KTX

SQLite-Erweiterungen umschließen SQL-Code in Transaktionen, wodurch viel Boilerplate-Code eliminiert wird.

Wenn Sie dieses Modul verwenden möchten, fügen Sie der Datei build.gradle Ihrer App Folgendes hinzu:

Groovy

dependencies {
    implementation "androidx.sqlite:sqlite-ktx:2.4.0"
}

Kotlin

dependencies {
    implementation("androidx.sqlite:sqlite-ktx:2.4.0")
}

Hier ein Beispiel für die Verwendung der transaction-Erweiterung zum Ausführen einer Datenbanktransaktion:

db.transaction {
    // insert data
}

ViewModel KTX

Die ViewModel-KTX-Bibliothek bietet eine viewModelScope()-Funktion, mit der sich Koroutinen einfacher über ViewModel starten lassen. CoroutineScope ist an Dispatchers.Main gebunden und wird automatisch abgebrochen, wenn ViewModel gelöscht wird. Sie können viewModelScope() verwenden, anstatt für jede ViewModel einen neuen Umfang zu erstellen.

Dazu fügen Sie der Datei build.gradle Ihrer App Folgendes hinzu:

Groovy

dependencies {
    implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:2.8.7"
}

Kotlin

dependencies {
    implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:2.8.7")
}

Die folgende viewModelScope()-Funktion startet beispielsweise eine Coroutine, die eine Netzwerkanfrage in einem Hintergrund-Thread stellt. Die Bibliothek übernimmt die gesamte Einrichtung und das entsprechende Löschen des Geltungsbereichs:

class MainViewModel : ViewModel() {
    // Make a network request without blocking the UI thread
    private fun makeNetworkRequest() {
        // launch a coroutine in viewModelScope
        viewModelScope.launch  {
            remoteApi.slowFetch()
            ...
        }
    }

    // No need to override onCleared()
}

WorkManager KTX

WorkManager KTX bietet erstklassige Unterstützung für Tasks.

Dazu fügen Sie der Datei build.gradle Ihrer App Folgendes hinzu:

Groovy

dependencies {
    implementation "androidx.work:work-runtime-ktx:2.9.1"
}

Kotlin

dependencies {
    implementation("androidx.work:work-runtime-ktx:2.9.1")
}

Anstatt Worker zu erweitern, können Sie jetzt CoroutineWorker erweitern, für das eine etwas andere API verwendet wird. Wenn Sie beispielsweise eine einfache CoroutineWorker zum Ausführen einiger Netzwerkvorgänge erstellen möchten, gehen Sie so vor:

class CoroutineDownloadWorker(context: Context, params: WorkerParameters)
        : CoroutineWorker(context, params) {

    override suspend fun doWork(): Result = coroutineScope {
        val jobs = (0 until 100).map {
            async {
                downloadSynchronously("https://www.google.com")
            }
        }

        // awaitAll will throw an exception if a download fails, which
        // CoroutineWorker will treat as a failure
        jobs.awaitAll()
        Result.success()
    }
}

Weitere Informationen zur Verwendung von CoroutineWorker finden Sie unter Threading in CoroutineWorker.

WorkManager KTX fügt Operations und ListenableFutures außerdem Erweiterungsfunktionen hinzu, um die aktuelle Coroutine anzuhalten.

Hier ein Beispiel, in dem die Operation, die von enqueue() zurückgegeben wird, angehalten wird:

// Inside of a coroutine...

// Run async operation and suspend until completed.
WorkManager.getInstance()
        .beginWith(longWorkRequest)
        .enqueue().await()

// Resume after work completes...

Andere KTX-Module

Sie können auch zusätzliche KTX-Module einschließen, die außerhalb von AndroidX existieren.

Firebase KTX

Einige der Firebase SDKs für Android haben Kotlin-Erweiterungsbibliotheken, mit denen Sie idiomatischen Kotlin-Code schreiben können, wenn Sie Firebase in Ihrer App verwenden. Weitere Informationen finden Sie in den folgenden Themen:

Google Maps Platform KTX

Für die Android SDKs der Google Maps Platform sind KTX-Erweiterungen verfügbar, mit denen Sie verschiedene Kotlin-Sprachfunktionen wie Erweiterungsfunktionen, benannte Parameter und Standardargumente, destrukturierende Deklarationen und Koroutinen nutzen können. Weitere Informationen finden Sie unter folgenden Links:

Play Core KTX

Play Core KTX unterstützt Kotlin-Koroutinen für einmalige Anfragen und Flow zum Überwachen von Statusaktualisierungen. Dazu werden in der Play Core-Bibliothek Erweiterungsfunktionen zu SplitInstallManager und AppUpdateManager hinzugefügt.

Dazu fügen Sie der Datei build.gradle Ihrer App Folgendes hinzu:

Groovy

dependencies {
    implementation "com.google.android.play:core-ktx:1.8.1"
}

Kotlin

dependencies {
    implementation("com.google.android.play:core-ktx:1.8.1")
}

Hier ein Beispiel für eine Flow für die Statusüberwachung:

// Inside of a coroutine...

// Request in-app update status updates.
manager.requestUpdateFlow().collect { updateResult ->
    when (updateResult) {
        is AppUpdateResult.Available -> TODO()
        is AppUpdateResult.InProgress -> TODO()
        is AppUpdateResult.Downloaded -> TODO()
        AppUpdateResult.NotAvailable -> TODO()
    }
}

Weitere Informationen

Weitere Informationen zu Android KTX finden Sie im DevBytes-Video.

Verwenden Sie den Android KTX-Issue-Tracker, um ein Problem zu melden oder eine Funktion vorzuschlagen.