Android KTX Zawiera Android Jetpack.

Android KTX to zestaw rozszerzeń Kotlin, które są dołączane do Androida. Jetpack i innych bibliotek Androida. Rozszerzenia KTX zawierają zwięzłe informacje, z Kotlin do Jetpacka, platformy Android i innych interfejsów API. W tym celu rozszerzenia wykorzystują kilka funkcji w języku Kotlin, między innymi:

  • Funkcje rozszerzeń
  • Właściwości rozszerzenia
  • Funkcje lambda
  • Nazwane parametry
  • Domyślne wartości parametru
  • Koutyny

Na przykład podczas pracy z SharedPreferences, musisz utwórz edytora przed wprowadzeniem zmian w danych preferencji. Musisz też złożyć wniosek lub zatwierdzić te zmiany po zakończeniu edytowania, jak pokazano poniżej. przykład:

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

W tym przypadku idealnie sprawdzają się lambda Kotlin. Umożliwiają one bardziej zwięzłe przez przesłanie bloku kodu do wykonania po zakończeniu edytora. utworzony, umożliwiający wykonanie kodu, a następnie umożliwić interfejsowi API SharedPreferences stosować je atomowo.

Oto przykład jednej z funkcji Androida KTX Core, SharedPreferences.edit co dodaje funkcję edycji do SharedPreferences. Ta funkcja przyjmuje opcjonalna flaga boolean jako pierwszy argument wskazujący, czy zatwierdzić lub zastosować zmiany. Dodatkowo otrzymuje działanie na SharedPreferences w postaci funkcji lambda.

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

Element wywołujący może zdecydować, czy zatwierdzić, czy zastosować zmiany. action lambda sama jest anonimową funkcją rozszerzenia w SharedPreferences.Editor , który zwraca Unit zgodnie z podpisem. Dlatego w możesz wykonać pracę bezpośrednio na SharedPreferences.Editor

Podpis SharedPreferences.edit() zawiera słowo kluczowe inline. To słowo kluczowe informuje kompilator Kotlin, że powinien skopiować i wkleić (lub inline) skompilowany kod bajtowy funkcji przy każdym jej użyciu. Pozwala to uniknąć nakładów związanych z tworzeniem nowej klasy dla każdego parametru action przy wywołaniu tej funkcji.

Ten sposób przekazywania kodu za pomocą funkcji lambda stosuje rozsądne ustawienia domyślne, można zastąpić i dodać te zachowania do istniejących interfejsów API za pomocą algorytmu inline funkcji rozszerzeń są typowe dla udoskonaleń dostępnych w Androidzie KTX. bibliotece.

Użyj Android KTX w swoim projekcie

Aby zacząć używać Androida KTX, dodaj tę zależność do parametru Plik build.gradle:

Odlotowe

repositories {
    google()
}

Kotlin

repositories {
    google()
}

Moduły AndroidX

Android KTX dzieli się na moduły, z których każdy zawiera przesyłek.

Musisz uwzględnić zależność dla każdego artefaktu modułu w tagu build.gradle. Pamiętaj, aby do artefaktu dołączyć numer wersji. Najnowsze numery wersji znajdziesz w odpowiedniej sekcji każdego artefaktu w tej kwestii.

Android KTX zawiera jednordzeniowy moduł udostępniający Kotlin. dla popularnych interfejsów API platformy oraz kilku rozszerzeń specyficznych dla danej domeny.

Z wyjątkiem modułu podstawowego wszystkie artefakty modułu KTX zastępują zależność Javy w pliku build.gradle. Możesz na przykład: zastąp zależność androidx.fragment:fragment wartością androidx.fragment:fragment-ktx Dzięki tej składni można lepiej zarządzać obsługi wersji i nie dodaje dodatkowych wymagań deklaracji zależności.

Core KTX

Moduł Core KTX zawiera rozszerzenia popularnych bibliotek, które są częścią platformy Android. Te biblioteki nie mają zależności opartych na Javie, które musisz dodać do build.gradle.

Aby uwzględnić ten moduł, do pliku build.gradle aplikacji dodaj ten kod:

Odlotowe

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

Kotlin

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

Oto lista pakietów, które zawiera moduł Core KTX:

Kolekcja KTX

Rozszerzenia kolekcji zawierają funkcje narzędziowe do pracy z biblioteki zbierania danych oszczędzające pamięć, w tym ArrayMap, LongSparseArray, LruCache i inne.

Aby korzystać z tego modułu, do pliku build.gradle dodaj te elementy:

Groovy

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

Kotlin

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

Rozszerzenia kolekcji wykorzystują przeciążenie operatora Kotlin do upraszczają takie elementy jak łączenie zbiorów, jak widać w tym przykładzie przykład:

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

Fragment KTX moduł udostępnia wiele rozszerzeń, aby uprościć interfejs API fragment.

Aby uwzględnić ten moduł, do pliku build.gradle aplikacji dodaj ten kod:

Odlotowe

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

Kotlin

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

Dzięki modułowi Fragment KTX możesz uprościć transakcje oparte na fragmentach za pomocą: lambda, na przykład:

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

Możesz też powiązać z ViewModel w jednym wierszu za pomocą elementów viewModels i Przedstawiciele usługi activityViewModels:

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

Cykl życia KTX

Cykl życia KTX definiuje LifecycleScope dla każdego Lifecycle. Dowolny współprogram Uruchomienie w tym zakresie zostaje anulowane po zniszczeniu obiektu Lifecycle. Dostępne opcje przejdź do: CoroutineScope, Lifecycle za pomocą usługi lifecycle.coroutineScope lub lifecycleOwner.lifecycleScope.

Aby uwzględnić ten moduł, do pliku build.gradle aplikacji dodaj ten kod:

Odlotowe

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

Kotlin

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

Ten przykład pokazuje, jak używać polecenia lifecycleOwner.lifecycleScope do: asynchronicznie utwórz wstępnie obliczony tekst:

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

Korzystanie z LiveData może wymagać asynchronicznego obliczania wartości. Dla: możesz na przykład pobrać preferencje użytkownika i udostępnić je Interfejs. W takich przypadkach LiveData KTX udostępnia funkcję konstruktora liveData, która wywołuje funkcję suspend i wyświetla wynik jako obiekt LiveData.

Aby uwzględnić ten moduł, do pliku build.gradle aplikacji dodaj ten kod:

Groovy

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

Kotlin

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

W poniższym przykładzie loadUser() to funkcja zawieszenia zadeklarowana w innym miejscu. Za pomocą funkcji konstruktora liveData możesz wywołać asynchronicznie loadUser(), a potem użyj emit() do wygenerowania wyniku:

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

Więcej informacji o używaniu współrzędnych z funkcją LiveData znajdziesz w artykule Użyj współrzędnych Kotlin z komponentami architektury.

Każdy komponent biblioteki Nawigacji ma własną wersję KTX, która dostosowuje jest bardziej zwięzły i idiotyczny w kotlinie.

Aby je uwzględnić, dodaj do pliku build.gradle aplikacji te moduły:

Odlotowe

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

Kotlin

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

Aby uzyskać dostęp do miejsca docelowego, użyj funkcji rozszerzenia i przekazywania właściwości i przejdź do miejsc docelowych, jak w tym przykładzie:

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

}

Paleta KTX

Moduł KTX z paletą oferuje idiomatyczne wsparcie Kotlina w pracy z paletami kolorów.

Aby korzystać z tego modułu, do pliku build.gradle dodaj te elementy:

Odlotowe

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

Kotlin

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

Na przykład podczas pracy z instancją Palette możesz pobrać Próbka pola selected dla danego parametru target przy użyciu operatora get ([ ]):

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

Transmisje reaktywne KTX

Moduł KTX Reaktywnych strumieni umożliwia utworzenie możliwego do obserwowania strumienia LiveData wydawca: ReactiveStreams.

Aby uwzględnić ten moduł, do pliku build.gradle aplikacji dodaj ten kod:

Odlotowe

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

Kotlin

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

Załóżmy na przykład, że używasz bazy danych z niewielką listą użytkowników. W aplikacji możesz: wczytać bazę danych do pamięci, a następnie wyświetlić dane użytkownika w swoim interfejsie użytkownika. Aby osiągnąć możesz użyć RxJava. Komponent Jetpack Room może pobierać listę użytkowników jako Flowable. W tym scenariuszu musisz również zarządzać modułem Rx subskrypcji wydawcy przez cały okres istnienia fragmentu lub aktywności.

Jednak dzięki interfejsowi LiveDataReactiveStreams możesz skorzystać z technologii RxJava z rozbudowanym zestawem operatorów i możliwości dotyczących harmonogramu pracy, a także prostoty funkcji LiveData w następujący sposób:

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

Pokój KTX

Rozszerzenia dotyczące pokoi dodają współgrające z obsługą transakcji w bazie danych.

Aby korzystać z tego modułu, do pliku build.gradle dodaj te elementy:

Odlotowe

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

Kotlin

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

Oto kilka przykładów, w których Room używa teraz współrzędnych. Pierwszy przykład korzysta z funkcji suspend do zwrócenia listy obiektów User, a drugi korzysta z Flow Kotlina aby asynchronicznie zwrócić listę User. Pamiętaj, że gdy używasz Flow, powiadomienia o wszelkich zmianach w tabelach, których dotyczy zapytanie.

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

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

SQLite KTX

Rozszerzenia SQLite opakowują kod związany z SQL w transakcjach, eliminując stały kod.

Aby korzystać z tego modułu, do pliku build.gradle dodaj te elementy:

Odlotowe

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

Kotlin

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

Oto przykład użycia rozszerzenia transaction do wykonania bazy danych transakcja:

db.transaction {
    // insert data
}

WyświetlModel KTX

Biblioteka ViewModel KTX zawiera funkcję viewModelScope(), dzięki której łatwiej jest uruchomić współrzędne na urządzeniu ViewModel. CoroutineScope jest powiązany z Dispatchers.Main i zostanie automatycznie anulowany po wyczyszczeniu ViewModel. Zamiast:viewModelScope() tworząc nowy zakres dla każdego pola ViewModel.

Aby uwzględnić ten moduł, do pliku build.gradle aplikacji dodaj ten kod:

Odlotowe

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

Kotlin

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

Na przykład ta funkcja viewModelScope() uruchamia współrzędną wysyłającego żądanie sieciowe w wątku w tle. Biblioteka obsługuje wszystkie konfigurację i usuwanie odpowiedniego zakresu:

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 zapewnia najwyższej klasy obsługę współprogramów.

Aby uwzględnić ten moduł, do pliku build.gradle aplikacji dodaj ten kod:

Odlotowe

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

Kotlin

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

Zamiast przedłużać termin Worker, możesz teraz przedłuż CoroutineWorker, który ma nieco inny interfejs API. Jeśli na przykład chcesz utworzyć prostą stronę CoroutineWorker, aby wykonać pewne operacje sieciowe, możesz wykonać te czynności:

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

Więcej informacji o korzystaniu z CoroutineWorker znajdziesz tutaj: Wątki w CooutineWorker.

WorkManager KTX dodaje też funkcje rozszerzeń do Operations i ListenableFutures, aby zawiesić bieżącą współudział.

Oto przykład zawieszenia Operation zwrócone przez enqueue():

// Inside of a coroutine...

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

// Resume after work completes...

Inne moduły KTX

Możesz też dołączyć dodatkowe moduły KTX, które istnieją poza AndroidemX.

Firebase – KTX

Niektóre pakiety SDK Firebase na Androida mają biblioteki rozszerzeń Kotlin, pozwalają na pisanie idiomatycznego kodu Kotlin podczas korzystania z Firebase w aplikacji. Dla: więcej informacji znajdziesz w tych tematach:

Google Maps Platform KTX

Dla pakietów SDK Google Maps Platform na Androida są dostępne rozszerzenia KTX, pozwalają na korzystanie z kilku funkcji językowych Kotlin, takich jak funkcje, parametry nazwane i argumenty domyślne, deklaracje zniszczenia i współdziałań. Więcej informacji znajdziesz w tych tematach:

Odtwórz Core KTX

W Play Core KTX dodaliśmy obsługę połączeń Kotlin w żądaniach 1 strzału i Flo monitorowania aktualizacji stanu przez dodanie funkcji rozszerzeń do SplitInstallManager i AppUpdateManager w bibliotece Google Play Core.

Aby uwzględnić ten moduł, do pliku build.gradle aplikacji dodaj ten kod:

Odlotowe

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

Kotlin

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

Oto przykład elementu Flow do monitorowania stanu:

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

Więcej informacji

Aby dowiedzieć się więcej o Androidzie KTX, obejrzyj film DevBytes.

Aby zgłosić problem lub zaproponować funkcję, skorzystaj z Narzędzie do zgłaszania problemów z Androidem KTX.