Android KTX Componente di Android Jetpack.
Android KTX è un insieme di estensioni Kotlin incluse in Android Jetpack e in altre librerie Android. Le estensioni di KTX offrono da Kotlin a Jetpack idiomatici e concisi, la piattaforma Android e altre API. A questo scopo, queste estensioni sfruttano diverse funzionalità in lingua Kotlin, tra cui:
- Funzioni delle estensioni
- Proprietà estensione
- Lambda
- Parametri con nome
- Valori predefiniti dei parametri
- Coroutine
Ad esempio, quando lavori con SharedPreferences
, devi creare un editor prima di poter apportare modifiche ai dati delle preferenze. Devi anche applicare o eseguire il commit di queste modifiche al termine della modifica, come mostrato nell'esempio seguente:
sharedPreferences
.edit() // create an Editor
.putBoolean("key", value)
.apply() // write to disk asynchronously
I lambda di Kotlin sono perfetti per questo caso d'uso. Ti consentono di adottare un approccio più conciso passando un blocco di codice da eseguire dopo la creazione dell'editor, lasciando che il codice venga eseguito e lasciando che l'API SharedPreferences
applichi le modifiche a livello atomico.
Ecco un esempio di una delle funzioni Android KTX Core, SharedPreferences.edit
, che aggiunge una funzione di modifica a SharedPreferences
. Questa funzione prende un
flag boolean
facoltativo come primo argomento che indica se eseguire il commit
o applicare le modifiche. Riceve inoltre un'azione da eseguire sull'editor SharedPreferences
sotto forma di 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) }
Il chiamante può scegliere se eseguire il commit delle modifiche o applicarle. La lambda action
è stessa una funzione di estensione anonima su SharedPreferences.Editor
che restituisce Unit
, come indicato dalla sua firma. Ecco perché all'interno del blocco puoi eseguire il lavoro direttamente su SharedPreferences.Editor
.
Infine, la firma SharedPreferences.edit()
contiene la parola chiave inline
.
Questa parola chiave indica al compilatore Kotlin che deve copiare e incollare (o incorporare) il bytecode compilato per la funzione ogni volta che viene usata la funzione.
In questo modo si evita l'overhead associato alla creazione di un'istanza di una nuova classe per ogni action
ogni
volta che viene chiamata questa funzione.
Questo pattern di trasferimento del codice mediante lambda, l'applicazione di valori predefiniti sensibili che possono essere sostituiti e l'aggiunta di questi comportamenti alle API esistenti mediante le funzioni di estensione di inline
è tipico dei miglioramenti forniti dalla libreria KTX di Android.
Usa Android KTX nel tuo progetto
Per iniziare a utilizzare Android KTX, aggiungi la seguente dipendenza al file build.gradle
del tuo progetto:
trendy
repositories { google() }
Kotlin
repositories { google() }
Moduli AndroidX
Android KTX è organizzato in moduli, dove ogni modulo contiene uno o più pacchetti.
Devi includere una dipendenza per ogni artefatto del modulo nel file build.gradle
dell'app. Ricordati di aggiungere il numero di versione all'artefatto.
Puoi trovare i numeri delle versioni più recenti nella sezione corrispondente di ogni artefatto in questo argomento.
Android KTX contiene un modulo singolo che fornisce estensioni Kotlin per le API framework comuni e diverse estensioni specifiche del dominio.
Ad eccezione del modulo principale, tutti gli artefatti del modulo KTX sostituiscono la
dipendenza Java sottostante nel file build.gradle
. Ad esempio, puoi
sostituire una dipendenza androidx.fragment:fragment
con
androidx.fragment:fragment-ktx
. Questa sintassi consente di gestire meglio il controllo delle versioni e non aggiunge ulteriori requisiti di dichiarazione delle dipendenze.
KTX di base
Il modulo Core KTX fornisce estensioni per le librerie comuni che fanno parte del framework Android. Queste librerie non hanno dipendenze basate su Java che
devi aggiungere a build.gradle
.
Per includere questo modulo, aggiungi quanto segue al file build.gradle
dell'app:
trendy
dependencies { implementation "androidx.core:core-ktx:1.13.1" }
Kotlin
dependencies { implementation("androidx.core:core-ktx:1.13.1") }
Di seguito è riportato un elenco dei pacchetti contenuti nel modulo Core KTX:
- androidx.core.animation.
- androidx.core.content
- androidx.core.content.res
- androidx.core.database
- androidx.core.database.sqlite
- androidx.core.graphics
- androidx.core.graphics.drawable
- androidx.core.location
- Androidx.core.net
- androidx.core.os
- Androidx.core.text
- Androidx.core.transition
- androidx.core.util
- Androidx.core.view
- androidx.core.widget
Collezione KTX
Le estensioni di raccolta contengono funzioni di utilità per utilizzare le librerie di raccolta efficienti in memoria di Android, tra cui ArrayMap
, LongSparseArray
, LruCache
e altre.
Per utilizzare questo modulo, aggiungi quanto segue al file build.gradle
dell'app:
Groovy
dependencies { implementation "androidx.collection:collection-ktx:1.3.0" }
Kotlin
dependencies { implementation("androidx.collection:collection-ktx:1.3.0") }
Le estensioni di raccolta sfruttano il sovraccarico degli operatori di Kotlin per semplificare operazioni come la concatenazione delle raccolte, come illustrato nel seguente esempio:
// 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
Frammento KTX
Il modulo Fragment KTX fornisce una serie di estensioni per semplificare l'API fragment.
Per includere questo modulo, aggiungi quanto segue al file build.gradle
dell'app:
trendy
dependencies { implementation "androidx.fragment:fragment-ktx:1.8.1" }
Kotlin
dependencies { implementation("androidx.fragment:fragment-ktx:1.8.1") }
Con il modulo Fragment KTX, puoi semplificare le transazioni con frammentazione con lambda, ad esempio:
fragmentManager().commit {
addToBackStack("...")
setCustomAnimations(
R.anim.enter_anim,
R.anim.exit_anim)
add(fragment, "...")
}
Puoi anche eseguire l'associazione a ViewModel
in una riga utilizzando i delegati delle proprietà viewModels
e
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>()
Ciclo di vita KTX
Il KTX del ciclo di vita definisce un LifecycleScope
per ogni oggetto Lifecycle
. Qualsiasi coroutine
lanciata in questo ambito viene annullata quando viene eliminato Lifecycle
. Puoi
accedere al CoroutineScope
del Lifecycle
utilizzando le
proprietà lifecycle.coroutineScope
o lifecycleOwner.lifecycleScope
.
Per includere questo modulo, aggiungi quanto segue al file build.gradle
dell'app:
trendy
dependencies { implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.8.3" }
Kotlin
dependencies { implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.8.3") }
L'esempio seguente mostra come utilizzare lifecycleOwner.lifecycleScope
per creare testo precalcolato in modo asincrono:
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)
}
}
}
KTX LiveData
Quando utilizzi LiveData, potresti dover calcolare i valori in modo asincrono. Ad esempio, potresti voler recuperare le preferenze di un utente e pubblicarle nella tua UI. In questi casi, KTX LiveData fornisce una funzione di creazione liveData
che
chiama una funzione suspend
e restituisce il risultato come oggetto LiveData
.
Per includere questo modulo, aggiungi quanto segue al file build.gradle
dell'app:
Groovy
dependencies { implementation "androidx.lifecycle:lifecycle-livedata-ktx:2.6.2" }
Kotlin
dependencies { implementation("androidx.lifecycle:lifecycle-livedata-ktx:2.6.2") }
Nell'esempio seguente, loadUser()
è una funzione di sospensione dichiarata altrove.
Puoi utilizzare la funzione di creazione liveData
per chiamare loadUser()
in modo asincrono,
quindi utilizzare emit()
per emettere il risultato:
val user: LiveData<User> = liveData {
val data = database.loadUser() // loadUser is a suspend function.
emit(data)
}
Per maggiori informazioni sull'utilizzo delle coroutine con LiveData
, consulta
Utilizzare le coroutine di Kotlin con i componenti dell'architettura.
Navigazione KTX
Ogni componente della libreria di navigazione ha una versione KTX che adatta l'API in modo che sia più concisa e idiomatica Kotlin.
Per includere questi moduli, aggiungi quanto segue al file build.gradle
dell'app:
Groovy
dependencies { implementation "androidx.navigation:navigation-runtime-ktx:2.7.5" implementation "androidx.navigation:navigation-fragment-ktx:2.7.5" implementation "androidx.navigation:navigation-ui-ktx:2.7.5" }
Kotlin
dependencies { implementation("androidx.navigation:navigation-runtime-ktx:2.7.5") implementation("androidx.navigation:navigation-fragment-ktx:2.7.5") implementation("androidx.navigation:navigation-ui-ktx:2.7.5") }
Utilizza le funzioni delle estensioni e la delega della proprietà per accedere agli argomenti delle destinazioni e raggiungere le destinazioni, come mostrato nell'esempio seguente:
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)
}
}
...
}
Tavolozza KTX
Il modulo Palette KTX offre il supporto Kotlin idiomatico per lavorare con le tavolozze dei colori.
Per utilizzare questo modulo, aggiungi quanto segue al file build.gradle
dell'app:
Groovy
dependencies { implementation "androidx.palette:palette-ktx:1.0.0" }
Kotlin
dependencies { implementation("androidx.palette:palette-ktx:1.0.0") }
Ad esempio, quando lavori con un'istanza Palette
, puoi recuperare il campione selected
per un determinato target
utilizzando l'operatore get ([ ]
):
val palette = Palette.from(bitmap).generate()
val swatch = palette[target]
Stream reattivi KTX
Il modulo KTX di Flussi reattivi consente di creare uno stream LiveData
osservabile da
un publisher ReactiveStreams
.
Per includere questo modulo, aggiungi quanto segue al file build.gradle
dell'app:
Groovy
dependencies { implementation "androidx.lifecycle:lifecycle-reactivestreams-ktx:2.8.3" }
Kotlin
dependencies { implementation("androidx.lifecycle:lifecycle-reactivestreams-ktx:2.8.3") }
Supponiamo ad esempio un database con un piccolo elenco di utenti. Nell'app, carichi il database in memoria e poi visualizzi i dati utente nella UI. Per ottenere questo risultato, puoi utilizzare RxJava.
Il componente Jetpack Room
può recuperare
l'elenco di utenti come Flowable
. In questo scenario, devi anche gestire l'abbonamento dell'editore Rx per tutta la durata del frammento o dell'attività.
Tuttavia, con LiveDataReactiveStreams
puoi trarre vantaggio da RxJava e dal suo ricco insieme di operatori e funzionalità di pianificazione del lavoro, lavorando al contempo con la semplicità di LiveData
, come mostrato nell'esempio seguente:
val fun getUsersLiveData() : LiveData<List<User>> {
val users: Flowable<List<User>> = dao.findUsers()
return LiveDataReactiveStreams.fromPublisher(users)
}
KTX sala
Le estensioni della stanza aggiungono il supporto delle coroutine per le transazioni del database.
Per utilizzare questo modulo, aggiungi quanto segue al file build.gradle
dell'app:
Alla moda
dependencies { implementation "androidx.room:room-ktx:2.6.1" }
Kotlin
dependencies { implementation("androidx.room:room-ktx:2.6.1") }
Ecco un paio di esempi in cui Room ora utilizza le coroutine. Il primo esempio utilizza una funzione suspend
per restituire un elenco di oggetti User
, mentre il secondo utilizza Flow
di Kotlin per restituire in modo asincrono l'elenco User
. Tieni presente che, quando utilizzi Flow
, riceverai
anche una notifica per eventuali modifiche alle tabelle su cui stai eseguendo query.
@Query("SELECT * FROM Users")
suspend fun getUsers(): List<User>
@Query("SELECT * FROM Users")
fun getUsers(): Flow<List<User>>
SQLite KTX
Le estensioni SQLite eseguono il wrapping del codice relativo a SQL nelle transazioni, eliminando una grande quantità di codice boilerplate.
Per utilizzare questo modulo, aggiungi quanto segue al file build.gradle
dell'app:
trendy
dependencies { implementation "androidx.sqlite:sqlite-ktx:2.4.0" }
Kotlin
dependencies { implementation("androidx.sqlite:sqlite-ktx:2.4.0") }
Ecco un esempio di utilizzo dell'estensione transaction
per eseguire una transazione del database:
db.transaction {
// insert data
}
ViewModel KTX
La libreria KTX ViewModel fornisce una funzione viewModelScope()
che semplifica l'avvio delle coroutine da ViewModel
. L'elemento CoroutineScope
è associato a Dispatchers.Main
e viene annullato automaticamente quando viene cancellato il valore ViewModel
. Puoi utilizzare viewModelScope()
anziché
creare un nuovo ambito per ogni ViewModel
.
Per includere questo modulo, aggiungi quanto segue al file build.gradle
dell'app:
trendy
dependencies { implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:2.8.3" }
Kotlin
dependencies { implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:2.8.3") }
Ad esempio, la seguente funzione viewModelScope()
avvia una coroutine
che effettua una richiesta di rete in un thread in background. La libreria gestisce tutte le configurazioni e la cancellazione dell'ambito corrispondente:
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 offre un supporto di primo livello per le coroutine.
Per includere questo modulo, aggiungi quanto segue al file build.gradle
dell'app:
Trendy
dependencies { implementation "androidx.work:work-runtime-ktx:2.9.0" }
Kotlin
dependencies { implementation("androidx.work:work-runtime-ktx:2.9.0") }
Anziché estendere Worker
, ora puoi
estendere CoroutineWorker
,
che ha un'API leggermente diversa. Ad esempio, se vuoi creare un CoroutineWorker
semplice per eseguire alcune operazioni di rete, puoi effettuare le seguenti operazioni:
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()
}
}
Per maggiori informazioni sull'uso di CoroutineWorker
, consulta
Threading in CoroutineWorker.
WorkManager KTX aggiunge anche funzioni di estensione a Operations
e
ListenableFutures
per sospendere la coroutine corrente.
Ecco un esempio in cui viene sospesa la risorsa Operation
restituita da enqueue()
:
// Inside of a coroutine...
// Run async operation and suspend until completed.
WorkManager.getInstance()
.beginWith(longWorkRequest)
.enqueue().await()
// Resume after work completes...
Altri moduli KTX
Puoi anche includere moduli KTX aggiuntivi esistenti al di fuori di AndroidX.
Firebase KTX
Alcuni SDK Firebase per Android dispongono di librerie di estensioni Kotlin che consentono di scrivere codice Kotlin idiomatico quando utilizzi Firebase nella tua app. Per saperne di più, consulta i seguenti argomenti:
KTX di Google Maps Platform
Sono disponibili estensioni KTX per gli SDK Android di Google Maps Platform che consentono di sfruttare diverse funzionalità in linguaggio Kotlin, come funzioni di estensione, parametri denominati e argomenti predefiniti, dichiarazioni destrutturate e coroutine. Per ulteriori informazioni, consulta i seguenti argomenti:
Gioca a Core KTX
Play Core KTX aggiunge il supporto delle coroutine Kotlin per le richieste one-shot e Flow per il monitoraggio degli aggiornamenti dello stato aggiungendo funzioni di estensione a
SplitInstallManager
e AppUpdateManager
nella libreria Play Core.
Per includere questo modulo, aggiungi quanto segue al file build.gradle
dell'app:
trendy
dependencies { implementation "com.google.android.play:core-ktx:1.8.1" }
Kotlin
dependencies { implementation("com.google.android.play:core-ktx:1.8.1") }
Ecco un esempio di monitoraggio dello stato 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()
}
}
Altre informazioni
Per ulteriori informazioni su Android KTX, guarda il video DevBytes.
Per segnalare un problema o suggerire una funzionalità, utilizza lo strumento Android KTX Issue Tracker.