Android KTX Teil von Android Jetpack

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

  • Erweiterungsfunktionen
  • Erweiterungseigenschaften
  • Lambdas
  • Benannte Parameter
  • Standardwerte der Parameter
  • Koroutinen

Wenn Sie zum Beispiel mit SharedPreferences, Sie müssen Editor erstellen bevor Sie Änderungen an den Einstellungsdaten vornehmen können. Sie müssen außerdem oder übernehmen Sie diese Änderungen, nachdem Sie die Bearbeitung abgeschlossen haben, wie im Folgenden gezeigt. Beispiel:

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

Kotlin-Lambdas sind für diesen Anwendungsfall perfekt geeignet. Sie ermöglichen es Ihnen, kompakteren Ansatz, bei dem ein Codeblock übergeben wird, der ausgeführt wird, nachdem der Editor den Code ausführen und dann die SharedPreferences API die Änderungen atomar anzuwenden.

Hier ist ein Beispiel für eine der Android KTX Core-Funktionen: SharedPreferences.edit, wodurch eine Bearbeitungsfunktion zu SharedPreferences hinzugefügt wird. Diese Funktion nimmt ein Optionales Flag boolean als erstes Argument, das angibt, ob ein Commit durchgeführt werden soll oder die Änderungen übernehmen. Er erhält auch eine Aktion, die auf dem SharedPreferences-Editor in Form einer Lambda-Funktion erstellt.

// 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 ein Commit durchgeführt oder die Änderungen angewendet werden sollen. Das action Lambda ist selbst eine anonyme Erweiterungsfunktion in SharedPreferences.Editor. wodurch Unit zurückgegeben wird, wie durch seine Signatur angegeben. Aus diesem Grund sollten Sie können Sie die Arbeit direkt auf der SharedPreferences.Editor

Die SharedPreferences.edit()-Signatur enthält schließlich das Schlüsselwort inline. Dieses Schlüsselwort teilt dem Kotlin-Compiler mit, dass er kopieren und einfügen soll (oder inline) den kompilierten Bytecode der Funktion bei jeder Verwendung. Dadurch wird der Aufwand für die Instanziierung einer neuen Klasse für jede action vermieden. Zeitpunkt des Aufrufs dieser Funktion.

Dieses Muster, bei dem Code mit Lambdas übergeben wird, wobei sinnvolle Standardwerte angewendet werden, und dieses Verhalten mithilfe von inline den vorhandenen APIs hinzugefügt werden. Erweiterungsfunktionen sind typisch für die Verbesserungen von Android KTX. Bibliothek.

Android KTX in Ihrem Projekt verwenden

Um Android KTX zu verwenden, fügen Sie die folgende Abhängigkeit zum build.gradle-Datei:

Cool

repositories {
    google()
}

Kotlin

repositories {
    google()
}

AndroidX-Module

Android KTX ist in Modulen organisiert, wobei jedes Modul ein oder mehrere Pakete.

Sie müssen für jedes Modulartefakt im build.gradle-Datei. Denken Sie daran, dem Artefakt die Versionsnummer anzuhängen. Die neuesten Versionsnummern finden Sie im entsprechenden Abschnitt jedes Artefakts in diesem Thema.

Android KTX enthält ein einzelnes Kernmodul mit Kotlin für gängige Framework-APIs und verschiedene domainspezifische Erweiterungen.

Mit Ausnahme des Kernmoduls ersetzen alle KTX-Modulartefakte das zugrunde liegende Java-Abhängigkeit in Ihrer build.gradle-Datei. So können Sie zum Beispiel androidx.fragment:fragment-Abhängigkeit ersetzen durch androidx.fragment:fragment-ktx. Diese Syntax hilft Ihnen, Versionsverwaltung und stellt keine zusätzlichen Anforderungen an die Abhängigkeitsdeklaration dar.

Core KTX

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

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

Cool

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

Kotlin

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

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

Sammlung KTX

Sammlungserweiterungen enthalten Dienstprogrammfunktionen für die Arbeit mit der speichereffiziente Sammlungsbibliotheken wie ArrayMap, LongSparseArray, LruCache und weitere.

Fügen Sie der Datei build.gradle Ihrer App Folgendes hinzu, um dieses Modul zu verwenden:

Cool

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

Kotlin

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

Sammlungserweiterungen nutzen die Überlastung des Kotlin-Operators und Dinge wie die Verkettung von Sammlungen vereinfachen, wie im Folgenden Beispiel:

// 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

KTX-Fragment

Die KTX-Modulfragment bietet eine Reihe von Erweiterungen zur Vereinfachung der Fragment API.

Wenn Sie dieses Modul verwenden möchten, 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 mit Lambdas. Beispiel:

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

Sie können auch in einer Zeile an eine ViewModel binden, indem Sie die viewModels und activityViewModels-Property-Delegierte:

// 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

Lifecycle-KTX definiert eine LifecycleScope für jede Objekt Lifecycle. Beliebige Koroutine in diesem Bereich gestartet, wird abgebrochen, wenn Lifecycle gelöscht wird. Sie können auf die CoroutineScope des Lifecycle mit der lifecycle.coroutineScope- oder lifecycleOwner.lifecycleScope-Property.

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

Cool

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

Kotlin

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

Das folgende Beispiel zeigt, wie Sie mit lifecycleOwner.lifecycleScope Vorberechneten 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

Bei der Verwendung von LiveData müssen Sie die Werte möglicherweise asynchron berechnen. Für So können Sie z. B. die Einstellungen eines Nutzers abrufen und Ihren UI. In diesen Fällen bietet LiveData KTX eine liveData-Builder-Funktion, ruft eine suspend-Funktion auf und liefert das Ergebnis als LiveData-Objekt.

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

Cool

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

Kotlin

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

Im folgenden Beispiel ist loadUser() eine an anderer Stelle deklarierte Sperrfunktion. Sie können die Builder-Funktion liveData verwenden, um loadUser() asynchron aufzurufen. und verwenden Sie dann emit(), 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 Koroutinen mit LiveData finden Sie unter Kotlin-Koroutinen mit Architekturkomponenten verwenden

Jede Komponente der Navigationsbibliothek verfügt über eine eigene KTX-Version, die die kürzer und Kotlin-idiomatischer zu formulieren.

Wenn Sie diese Module einbinden möchten, fügen Sie der Datei build.gradle Ihrer App Folgendes hinzu:

Cool

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

Kotlin

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

Erweiterungsfunktionen und Attributdelegierung für den Zugriff auf das Ziel verwenden und navigieren Sie zu Zielen, 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

Die Palette KTX-Modul bietet idiomatischen Kotlin-Support für die Arbeit mit Farbvorlagen.

Fügen Sie der Datei build.gradle Ihrer App Folgendes hinzu, um dieses Modul zu verwenden:

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 den selected-Muster für eine bestimmte target mit dem get-Operator ([ ]):

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

Reaktive Streams KTX

Mit dem KTX-Modul von Reactive Streams kannst du einen erfassbaren LiveData-Stream aus ein ReactiveStreams-Publisher.

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

Cool

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

Kotlin

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

Nehmen wir als Beispiel an, dass es sich um eine Datenbank mit einer kleinen Liste von Nutzern handelt. In Ihrer App die Datenbank in den Arbeitsspeicher laden und dann Nutzerdaten in Ihrer UI anzeigen. Ziel können Sie RxJava verwenden. Die Jetpack-Komponente von Room kann Nutzerliste als Flowable. In diesem Szenario müssen Sie auch die Rx- für die gesamte Lebensdauer des Fragments oder Ihrer Aktivität.

Mit LiveDataReactiveStreams können Sie jedoch von RxJava und dessen zahlreiche Operatoren und Funktionen zur Arbeitsplanung. die Einfachheit von LiveData, wie im folgenden Beispiel gezeigt:

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

Raum KTX

Raumerweiterungen unterstützen Koroutinen für Datenbanktransaktionen.

Fügen Sie der Datei build.gradle Ihrer App Folgendes hinzu, um dieses Modul zu verwenden:

Cool

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 in Room Koroutinen verwendet werden. Das erste Beispiel verwendet eine suspend-Funktion, um eine Liste von User-Objekten zurückzugeben, während das zweite mit Flow von Kotlin um die User-Liste asynchron zurückzugeben. Wenn Sie Flow verwenden, werden auch über Änderungen in den abgefragten Tabellen informiert.

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

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

SQLite KTX

SQLite-Erweiterungen verpacken SQL-bezogenen Code in Transaktionen und eliminieren so viele Boilerplate-Code.

Fügen Sie der Datei build.gradle Ihrer App Folgendes hinzu, um dieses Modul zu verwenden:

Cool

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

Kotlin

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

Hier ist ein Beispiel für die Verwendung der Erweiterung transaction zum Ausführen einer Datenbank Transaktion:

db.transaction {
    // insert data
}

ViewModel KTX

Die ViewModel KTX-Bibliothek bietet eine viewModelScope()-Funktion, die ist es einfacher, gemeinsame Abläufe auf ViewModel zu starten. Die CoroutineScope ist an Dispatchers.Main gebunden und wird automatisch storniert wenn ViewModel gelöscht wird. Sie können viewModelScope() verwenden statt Erstellen eines neuen Umfangs für jede ViewModel.

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

Cool

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

Kotlin

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

Die folgende viewModelScope()-Funktion startet beispielsweise eine Koroutine. die eine Netzwerkanfrage in einem Hintergrundthread sendet. Die Bibliothek übernimmt alle Einrichtung und Löschen des entsprechenden Bereichs:

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 Koroutinen.

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

Cool

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, mit einer etwas anderen API. Wenn Sie z. B. ein einfaches CoroutineWorker zum Ausführen einiger Netzwerkvorgänge haben Sie folgende Möglichkeiten:

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 auch Erweiterungsfunktionen zu Operations und ListenableFutures, um die aktuelle Koroutine anzuhalten.

Hier ist ein Beispiel, bei dem die Operation, das von enqueue():

// Inside of a coroutine...

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

// Resume after work completes...

Weitere KTX-Module

Sie können auch zusätzliche KTX-Module einbinden, die nicht in AndroidX vorhanden sind.

Firebase KTX

Einige der Firebase SDKs für Android haben Kotlin-Erweiterungsbibliotheken, ermöglichen es Ihnen, idiomatischen Kotlin-Code zu schreiben, wenn Sie Firebase in Ihrer App verwenden. Für Weitere Informationen finden Sie in den folgenden Themen:

Google Maps Platform KTX

Für die Google Maps Platform Android SDKs sind KTX-Erweiterungen verfügbar, Kotlin-Sprachfunktionen wie die Erweiterung Funktionen, benannte Parameter und Standardargumente, destruktive Deklarationen und Koroutinen. Weitere Informationen finden Sie in den folgenden Themen:

Play Core KTX

Play Core KTX unterstützt Kotlin-Koroutinen für One-Shot-Anfragen und Flow um Statusaktualisierungen zu überwachen, indem Sie Erweiterungsfunktionen SplitInstallManager und AppUpdateManager in der Play Core-Bibliothek.

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

Cool

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 Statusüberwachung Flow:

// 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 findest du im DevBytes-Video.

Wenn du ein Problem melden oder eine Funktion vorschlagen möchtest, verwende die Android KTX-Problemverfolgung