Android KTX Parte di Android Jetpack .
Android KTX è un insieme di estensioni Kotlin incluse in Android Jetpack e altre librerie Android. Le estensioni KTX offrono contenuti concisi, da Kotlin a Jetpack, alla piattaforma Android e ad altre API. A questo scopo, le estensioni sfruttano diverse funzionalità del linguaggio Kotlin, tra cui:
- Funzioni estensione
- Proprietà estensione
- Lambda
- Parametri con nome
- Valori predefiniti dei parametri
- Coroutine
Ad esempio, quando si lavora
SharedPreferences
, devi crea un editor
prima di poter apportare modifiche ai dati delle preferenze. Devi inoltre presentare domanda oppure eseguire il commit di tali modifiche al termine delle modifiche, come illustrato di seguito esempio:
sharedPreferences
.
edit
()
// create an Editor
.
putBoolean
(
" key
" ,
value
)
.
apply
()
// write to disk asynchronously
Kotlin lambdas è una soluzione perfetta per questo caso d'uso. Consentono di acquisire un approccio più conciso passando un blocco di codice da eseguire dopo che e poi consentire l'esecuzione del codice e poi l'API SharedPreferences
per applicare le modifiche a livello atomico.
Ecco un esempio di una delle funzioni principali di Android KTX:
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 Editor di 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 o applicare le modifiche. action
lambda è una funzione di estensione anonima su SharedPreferences.Editor
che restituisce Unit
, come indicato dalla sua firma. Questo è il motivo per cui all'interno blocco, puoi eseguire il lavoro direttamente SharedPreferences.Editor
.
Infine, la firma SharedPreferences.edit()
contiene la parola chiave inline
. Questa parola chiave indica al compilatore Kotlin che deve copiare e incollare (oppure inline
) il bytecode compilato per la funzione ogni volta che viene utilizzata. In questo modo si evita di creare un'istanza per un nuovo corso per ogni action
. volta che viene chiamata questa funzione.
Questo pattern di passaggio del codice mediante lambda e l'applicazione di valori predefiniti sensibili che possono eseguire l'override e aggiungere questi comportamenti alle API esistenti utilizzando inline
le funzioni di estensione sono tipiche dei miglioramenti offerti da Android KTX libreria.
Usa Android KTX nel tuo progetto
Per iniziare a utilizzare Android KTX, aggiungi la seguente dipendenza File build.gradle
:
Alla moda
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 build.gradle
. Ricordati di aggiungere il numero di versione all'artefatto. Puoi trovare gli ultimi numeri di versione nella sezione corrispondente di ogni artefatto in questo argomento.
Android KTX contiene un modulo single-core che fornisce Kotlin per le API del framework comune e per varie estensioni specifiche del dominio.
Ad eccezione del modulo principale, tutti gli artefatti del modulo KTX sostituiscono il alla dipendenza Java sottostante nel file build.gradle
. Ad esempio, puoi sostituisci una dipendenza androidx.fragment:fragment
con androidx.fragment:fragment-ktx
. Questa sintassi aiuta a gestire meglio delle versioni e non aggiunge ulteriori requisiti di dichiarazione delle dipendenze.
Core KTX
Il modulo Core KTX fornisce estensioni per le librerie comuni che fanno parte il framework Android. Queste librerie non hanno dipendenze basate su Java che da aggiungere a build.gradle
.
Per includere questo modulo, aggiungi quanto segue al file build.gradle
dell'app:
Alla moda
dependencies { implementation "androidx.core:core-ktx:1.13.1" }
Kotlin
dependencies { implementation("androidx.core:core-ktx:1.13.1") }
Ecco 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 Raccolta contengono funzioni di utilità per l'uso del librerie a elevata efficienza della memoria, tra cui ArrayMap
, LongSparseArray
, LruCache
e altri.
Per utilizzare questo modulo, aggiungi quanto segue al file build.gradle
dell'app:
Alla moda
dependencies { implementation "androidx.collection:collection-ktx:1.4.3" }
Kotlin
dependencies { implementation("androidx.collection:collection-ktx:1.4.3") }
Le estensioni di raccolta sfruttano il sovraccarico dell'operatore di Kotlin semplificare cose come la concatenazione delle raccolte, come mostrato di seguito 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
KTX frammento
La Modulo KTX a frammentazione fornisce una serie di estensioni per semplificare l'API fragment.
Per includere questo modulo, aggiungi quanto segue al file build.gradle
dell'app:
Alla moda
dependencies { implementation "androidx.fragment:fragment-ktx:1.8.2" }
Kotlin
dependencies { implementation("androidx.fragment:fragment-ktx:1.8.2") }
Con il modulo Fragment KTX, puoi semplificare le transazioni con frammenti con lambdas, ad esempio:
fragmentManager
().
commit
{
addToBackStack
("...")
setCustomAnimations
(
R
.
anim
.
enter_anim
,
R
.
anim
.
exit_anim
)
add
(
fragment
,
" ...")
}
Puoi anche eseguire l'associazione a un ViewModel
su una riga utilizzando viewModels
e activityViewModels
delegati della proprietà:
// 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
KTX del ciclo di vita definisce un LifecycleScope
per ogni
Lifecycle
. Qualsiasi coroutine avviato in questo ambito viene annullato quando l'elemento Lifecycle
viene eliminato. Puoi accedi a CoroutineScope
di Lifecycle
utilizzando Proprietà lifecycle.coroutineScope
o lifecycleOwner.lifecycleScope
.
Per includere questo modulo, aggiungi quanto segue al file build.gradle
dell'app:
Alla moda
dependencies { implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.8.4" }
Kotlin
dependencies { implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.8.4") }
L'esempio seguente mostra come utilizzare lifecycleOwner.lifecycleScope
per 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, potrebbe essere necessario calcolare i valori in modo asincrono. Per Ad esempio, puoi recuperare le preferenze di un utente e pubblicarle nell'interfaccia utente. In questi casi, LiveData KTX 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:
Alla moda
dependencies { implementation "androidx.lifecycle:lifecycle-livedata-ktx:2.8.4" }
Kotlin
dependencies { implementation("androidx.lifecycle:lifecycle-livedata-ktx:2.8.4") }
Nell'esempio seguente, loadUser()
è una funzione di sospensione dichiarata altrove. Puoi utilizzare la funzione di creazione di liveData
per chiamare loadUser()
in modo asincrono, quindi usa emit()
per emettere il risultato:
val
user
:
LiveData<User>
=
liveData
{
val
data
=
database
.
loadUser
()
// loadUser is a suspend function.
emit
(
data
)
}
Per ulteriori informazioni sull'uso delle coroutine con LiveData
, vedi Utilizza le coroutine Kotlin con i componenti Architecture
.
Navigazione KTX
Ogni componente della libreria di navigazione ha la propria versione KTX che adatta la l'API in modo che sia più concisa e idiomatica Kotlin.
Per includere questi moduli, aggiungi quanto segue al file build.gradle
dell'app:
Alla moda
dependencies { implementation "androidx.navigation:navigation-runtime-ktx:2.7.7" implementation "androidx.navigation:navigation-fragment-ktx:2.7.7" implementation "androidx.navigation:navigation-ui-ktx:2.7.7" }
Kotlin
dependencies { implementation("androidx.navigation:navigation-runtime-ktx:2.7.7") implementation("androidx.navigation:navigation-fragment-ktx:2.7.7") implementation("androidx.navigation:navigation-ui-ktx:2.7.7") }
Utilizza le funzioni dell'estensione e la delega delle proprietà per accedere alla destinazione argomenti e vai alle destinazioni, come illustrato 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
)
}
}
...
}
Palette KTX
La Modulo KTX con tavolozza offre un supporto Kotlin idiomatico per l'uso delle tavolozze dei colori.
Per utilizzare questo modulo, aggiungi quanto segue al file build.gradle
dell'app:
Alla moda
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 Campione selected
per un determinato target
mediante l'operatore get ([ ]
):
val
palette
=
Palette
.
from
(
bitmap
).
generate
()
val
swatch
=
palette
[
target
]
Stream reattivi KTX
Il modulo KTX Reactive Streams consente di creare uno stream LiveData
osservabile da un publisher ReactiveStreams
.
Per includere questo modulo, aggiungi quanto segue al file build.gradle
dell'app:
Alla moda
dependencies { implementation "androidx.lifecycle:lifecycle-reactivestreams-ktx:2.8.4" }
Kotlin
dependencies { implementation("androidx.lifecycle:lifecycle-reactivestreams-ktx:2.8.4") }
Ad esempio, supponiamo che un database abbia un piccolo elenco di utenti. Nella tua app, caricare il database in memoria e visualizzare i dati utente nella UI. Per raggiungere questo, potresti utilizzare RxJava
. Il componente Jetpack
Room
può recuperare l'elenco utenti come Flowable
. In questo scenario, devi anche gestire il file Rx abbonamento all'editore per tutta la durata del frammento o dell'attività.
Con LiveDataReactiveStreams
, invece, puoi trarre vantaggio da RxJava e i suoi un ricco set di operatori e funzionalità di pianificazione del lavoro, lavorando al tempo stesso 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 dei 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 ora Room utilizza le coroutine. Il primo esempio utilizza una funzione suspend
per restituire un elenco di User
oggetti, mentre la seconda utilizza
Flow
di Kotlin per restituire in modo asincrono l'elenco User
. Tieni presente che quando utilizzi Flow
, notifica anche eventuali modifiche nelle tabelle su cui esegui le query.
@Query
(
" SELECT
*
FROM
Users
" )
suspend
fun
getUsers
():
List<User>
@Query
(
" SELECT
*
FROM
Users
" )
fun
getUsers
():
Flow<List<User>
>
SQLite KTX
Le estensioni SQLite aggregano il codice relativo a SQL nelle transazioni, eliminando gran parte il codice boilerplate.
Per utilizzare questo modulo, aggiungi quanto segue al file build.gradle
dell'app:
Alla moda
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 un database transazione:
db
.
transaction
{
// insert data
}
ViewModel KTX
La libreria KTX ViewModel fornisce una funzione viewModelScope()
che lo rende è più facile avviare le coroutine
dal tuo ViewModel
. La
CoroutineScope
è associato a Dispatchers.Main
e viene automaticamente annullato quando ViewModel
viene cancellato. Puoi utilizzare viewModelScope()
al posto di creando un nuovo ambito per ogni ViewModel
.
Per includere questo modulo, aggiungi quanto segue al file build.gradle
dell'app:
Alla moda
dependencies { implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:2.8.4" }
Kotlin
dependencies { implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:2.8.4") }
Ad esempio, la seguente funzione viewModelScope()
avvia una coroutine che effettua una richiesta di rete in un thread in background. La libreria gestisce tutti i la configurazione 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'assistenza di alto livello per le coroutine.
Per includere questo modulo, aggiungi quanto segue al file build.gradle
dell'app:
Alla moda
dependencies { implementation "androidx.work:work-runtime-ktx:2.9.1" }
Kotlin
dependencies { implementation("androidx.work:work-runtime-ktx:2.9.1") }
Invece di estendere
Worker
, ora puoi estendi
CoroutineWorker
, che ha un'API leggermente diversa. Ad esempio, se volessi creare una semplice CoroutineWorker
per eseguire alcune operazioni di rete, puoi:
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 ulteriori informazioni sull'utilizzo di CoroutineWorker
, vedi Threading in CoroutineWorker
.
WorkManager KTX aggiunge anche funzioni estensione a Operations
e ListenableFutures
per sospendere l'attuale coroutine.
Ecco un esempio che sospende
Operation
restituito 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 al di fuori di AndroidX.
KTX Firebase
Alcuni SDK Firebase per Android dispongono di librerie di estensioni Kotlin che che ti consentono di scrivere codice Kotlin idiomatico quando utilizzi Firebase nella tua app. Per per ulteriori informazioni, consulta i seguenti argomenti:
Google Maps Platform KTX
Sono disponibili estensioni KTX per gli SDK Android di Google Maps Platform, consentono di sfruttare diverse funzionalità del linguaggio Kotlin, come le estensioni funzioni, parametri denominati e argomenti predefiniti, dichiarazioni di destrutturazione, 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 monitorare gli aggiornamenti dello stato aggiungendo funzioni di estensione a SplitInstallManager
e AppUpdateManager
nella raccolta Play Core.
Per includere questo modulo, aggiungi quanto segue al file build.gradle
dell'app:
Alla moda
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 Flow
di monitoraggio dello stato:
// 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
()
}
}
Ulteriori informazioni
Per scoprire di più su Android KTX, guarda il video di DevOps .
Per segnalare un problema o suggerire una funzione, utilizza Issue Tracker KTX di Android .