Questa pagina è stata tradotta dall'API Cloud Translation.

Ciclo di vita

Guida dell'utente Esempio di codice Codelab

I componenti attenti al ciclo di vita eseguono azioni in risposta a una modifica dello stato del ciclo di vita di un altro componente, ad esempio attività e frammenti. Questi componenti ti aiutano a produrre codice meglio organizzato e spesso più leggero, che è più facile da mantenere.

Questa tabella elenca tutti gli elementi nel gruppo androidx.lifecycle.

Elemento	Release stabile	Candidato per la release	Versione beta	Versione alpha
lifecycle-*	2.8.7	-	-	2.9.0-alpha07
lifecycle-viewmodel-compose	2.8.7	-	-	2.9.0-alpha07

Questa libreria è stata aggiornata l'ultima volta il 13 novembre 2024

Dichiarazione delle dipendenze

Per aggiungere una dipendenza da Lifecycle, devi aggiungere il repository Maven di Google al tuo progetto. Per ulteriori informazioni, consulta il repository Maven di Google.

Aggiungi le dipendenze per gli elementi necessari nel file build.gradle per la tua app o il tuo modulo:

Le API in lifecycle-extensions sono state ritirate. Aggiungi invece le dipendenze per gli elementi del ciclo di vita specifici di cui hai bisogno.

Kotlin

Alla moda

    dependencies {
        def lifecycle_version = "2.8.7"
        def arch_version = "2.2.0"

        // ViewModel
        implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version"
        // ViewModel utilities for Compose
        implementation "androidx.lifecycle:lifecycle-viewmodel-compose:$lifecycle_version"
        // LiveData
        implementation "androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle_version"
        // Lifecycles only (without ViewModel or LiveData)
        implementation "androidx.lifecycle:lifecycle-runtime-ktx:$lifecycle_version"
        // Lifecycle utilities for Compose
        implementation "androidx.lifecycle:lifecycle-runtime-compose:$lifecycle_version"

        // Saved state module for ViewModel
        implementation "androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version"

        // Annotation processor
        kapt "androidx.lifecycle:lifecycle-compiler:$lifecycle_version"
        // alternately - if using Java8, use the following instead of lifecycle-compiler
        implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"

        // optional - helpers for implementing LifecycleOwner in a Service
        implementation "androidx.lifecycle:lifecycle-service:$lifecycle_version"

        // optional - ProcessLifecycleOwner provides a lifecycle for the whole application process
        implementation "androidx.lifecycle:lifecycle-process:$lifecycle_version"

        // optional - ReactiveStreams support for LiveData
        implementation "androidx.lifecycle:lifecycle-reactivestreams-ktx:$lifecycle_version"

        // optional - Test helpers for LiveData
        testImplementation "androidx.arch.core:core-testing:$arch_version"

        // optional - Test helpers for Lifecycle runtime
        testImplementation "androidx.lifecycle:lifecycle-runtime-testing:$lifecycle_version"
    }

Kotlin

    dependencies {
        val lifecycle_version = "2.8.7"
        val arch_version = "2.2.0"

        // ViewModel
        implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version")
        // ViewModel utilities for Compose
        implementation("androidx.lifecycle:lifecycle-viewmodel-compose:$lifecycle_version")
        // LiveData
        implementation("androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle_version")
        // Lifecycles only (without ViewModel or LiveData)
        implementation("androidx.lifecycle:lifecycle-runtime-ktx:$lifecycle_version")
        // Lifecycle utilities for Compose
        implementation("androidx.lifecycle:lifecycle-runtime-compose:$lifecycle_version")

        // Saved state module for ViewModel
        implementation("androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version")

        // Annotation processor
        kapt("androidx.lifecycle:lifecycle-compiler:$lifecycle_version")
        // alternately - if using Java8, use the following instead of lifecycle-compiler
        implementation("androidx.lifecycle:lifecycle-common-java8:$lifecycle_version")

        // optional - helpers for implementing LifecycleOwner in a Service
        implementation("androidx.lifecycle:lifecycle-service:$lifecycle_version")

        // optional - ProcessLifecycleOwner provides a lifecycle for the whole application process
        implementation("androidx.lifecycle:lifecycle-process:$lifecycle_version")

        // optional - ReactiveStreams support for LiveData
        implementation("androidx.lifecycle:lifecycle-reactivestreams-ktx:$lifecycle_version")

        // optional - Test helpers for LiveData
        testImplementation("androidx.arch.core:core-testing:$arch_version")

        // optional - Test helpers for Lifecycle runtime
        testImplementation ("androidx.lifecycle:lifecycle-runtime-testing:$lifecycle_version")
    }

Java

Groovy

    dependencies {
        def lifecycle_version = "2.8.7"
        def arch_version = "2.2.0"

        // ViewModel
        implementation "androidx.lifecycle:lifecycle-viewmodel:$lifecycle_version"
        // LiveData
        implementation "androidx.lifecycle:lifecycle-livedata:$lifecycle_version"
        // Lifecycles only (without ViewModel or LiveData)
        implementation "androidx.lifecycle:lifecycle-runtime:$lifecycle_version"

        // Saved state module for ViewModel
        implementation "androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version"

        // Annotation processor
        annotationProcessor "androidx.lifecycle:lifecycle-compiler:$lifecycle_version"
        // alternately - if using Java8, use the following instead of lifecycle-compiler
        implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"

        // optional - helpers for implementing LifecycleOwner in a Service
        implementation "androidx.lifecycle:lifecycle-service:$lifecycle_version"

        // optional - ProcessLifecycleOwner provides a lifecycle for the whole application process
        implementation "androidx.lifecycle:lifecycle-process:$lifecycle_version"

        // optional - ReactiveStreams support for LiveData
        implementation "androidx.lifecycle:lifecycle-reactivestreams:$lifecycle_version"

        // optional - Test helpers for LiveData
        testImplementation "androidx.arch.core:core-testing:$arch_version"

        // optional - Test helpers for Lifecycle runtime
        testImplementation "androidx.lifecycle:lifecycle-runtime-testing:$lifecycle_version"
    }

Kotlin

    dependencies {
        val lifecycle_version = "2.8.7"
        val arch_version = "2.2.0"

        // ViewModel
        implementation("androidx.lifecycle:lifecycle-viewmodel:$lifecycle_version")
        // LiveData
        implementation("androidx.lifecycle:lifecycle-livedata:$lifecycle_version")
        // Lifecycles only (without ViewModel or LiveData)
        implementation("androidx.lifecycle:lifecycle-runtime:$lifecycle_version")

        // Saved state module for ViewModel
        implementation("androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version")

        // Annotation processor
        annotationProcessor("androidx.lifecycle:lifecycle-compiler:$lifecycle_version")
        // alternately - if using Java8, use the following instead of lifecycle-compiler
        implementation("androidx.lifecycle:lifecycle-common-java8:$lifecycle_version")

        // optional - helpers for implementing LifecycleOwner in a Service
        implementation("androidx.lifecycle:lifecycle-service:$lifecycle_version")

        // optional - ProcessLifecycleOwner provides a lifecycle for the whole application process
        implementation("androidx.lifecycle:lifecycle-process:$lifecycle_version")

        // optional - ReactiveStreams support for LiveData
        implementation("androidx.lifecycle:lifecycle-reactivestreams:$lifecycle_version")

        // optional - Test helpers for LiveData
        testImplementation("androidx.arch.core:core-testing:$arch_version")

        // optional - Test helpers for Lifecycle runtime
        testImplementation("androidx.lifecycle:lifecycle-runtime-testing:$lifecycle_version")
    }

Per ulteriori informazioni sulle dipendenze, consulta Aggiungere dipendenze di compilazione.

Feedback

Il tuo feedback ci aiuta a migliorare Jetpack. Facci sapere se riscontri nuovi problemi o hai idee per migliorare questa raccolta. Prima di crearne uno nuovo, dai un'occhiata ai problemi esistenti in questa raccolta. Puoi aggiungere il tuo voto a un problema esistente facendo clic sul pulsante a forma di stella.

Creare un nuovo problema

Per ulteriori informazioni, consulta la documentazione del Monitoraggio problemi.

Versione 2.9

Versione 2.9.0-alpha07

13 novembre 2024

androidx.lifecycle:lifecycle-*:2.9.0-alpha07 viene rilasciato. La versione 2.9.0-alpha07 contiene questi commit.

Compatibilità con Kotlin Multiplatform

Il ciclo di vita ViewModel SavedState ora è compatibile con KMP. In questo modo puoi utilizzare SavedStateHandle nel codice comune. (Ib6394, b/334076622)

Supporto della serializzazione KotlinX

Con il supporto della serializzazione KotlinX aggiunto in SavedState 1.3.0-alpha05, abbiamo introdotto saved, un delegato della proprietà lazy, per semplificare lo stoccaggio delle classi @Serializable in un SavedStateHandle e il loro ripristino automatico dopo l'interruzione e la ricreazione del processo. Tieni presente che il delegato saved è lazy e non chiamerà la funzione lambda init né salverà nulla in SavedStateHandle finché non viene eseguito l'accesso. (I47a88, b/376026744)
```
@Serializable
data class Person(val firstName: String, val lastName: String)

class MyViewModel(handle: SavedStateHandle) : ViewModel() {
    var person by handle.saved { Person("John", "Doe") }

    fun onPersonChanged(person: Person) {
        this.person = person
    }
}
```

Modifiche all'API

Aggiungi getMutableStateFlow a SavedStateHandle per restituire un MutableStateFlow. Questa nuova funzione è esclusiva per le chiavi e non può essere utilizzata con getLiveData. Se provi a utilizzarli entrambi per accedere allo stesso stato, verrà generata un'eccezione. (I04a4f, b/375408415)

Versione 2.9.0-alpha06

30 ottobre 2024

androidx.lifecycle:lifecycle-*:2.9.0-alpha06 viene rilasciato. La versione 2.9.0-alpha06 contiene questi commit.

Modifiche al comportamento

Lo stato Lifecycle.DESTROYED è terminale e qualsiasi tentativo di spostare un Lifecycle da questo stato a un altro stato ora comporterà un IllegalStateException. (I116c4, b/370577987)
SavedStateHandle non include più SavedStateProvider.saveState() in cui Bundle restituito è vuoto. (I910b5, b/370577987)

Correzioni di bug

Lifecycle.eventFlow ora viene completato correttamente quando Lifecycle è DESTROYED (I293b2, b/374043130)

Versione 2.9.0-alpha05

16 ottobre 2024

androidx.lifecycle:lifecycle-*:2.9.0-alpha05 viene rilasciato senza modifiche significative. La versione 2.9.0-alpha05 contiene questi commit.

Versione 2.9.0-alpha04

2 ottobre 2024

androidx.lifecycle:lifecycle-*:2.9.0-alpha04 viene rilasciato. La versione 2.9.0-alpha04 contiene questi commit.

Kotlin Multiplatform

Il modulo lifecycle-viewmodel-savedstate è ora configurato per essere compatibile con KMP in vista della disponibilità di API come SavedStateHandle nel set di origine comune in una release futura. (I503ed, I48764, b/334076622)

Versione 2.9.0-alpha03

18 settembre 2024

androidx.lifecycle:lifecycle-*:2.9.0-alpha03 viene rilasciato. La versione 2.9.0-alpha03 contiene questi commit.

Correzioni di bug

Da Lifecycle 2.8.6: l'errore Lint NullSafeMutableLiveData ha migliorato il supporto per le trasmissioni intelligenti, evitando falsi positivi. (85fed6, b/181042665)

Aggiornamenti delle dipendenze

Da Ciclo di vita 2.8.6: Compose Runtime del ciclo di vita ora dipende da Compose Runtime 1.7.1
Il runtime del ciclo di vita ora dipende da ProfileInstaller 1.4.0

Versione 2.9.0-alpha02

4 settembre 2024

androidx.lifecycle:lifecycle-*:2.9.0-alpha02 viene rilasciato. La versione 2.9.0-alpha02 contiene questi commit.

Correzioni di bug

In Ciclo di vita 2.8.5: aggiorna le regole di androidx.lifecycle.ReportFragment ProGuard per consentire l'oscuramento . (ff898e1)

Contributo esterno

Sposta androidx.compose.ui.platform.LocalLifecycleOwner nell'insieme di origini comuni (KMP). Grazie a Ivan Matkov di JetBrains per il contributo. (8cd5d03)
Da Lifecycle 2.8.5: il delegato dell'estensione SavedStateHandle.saveable ora supporta i valori null. Grazie a Roman Kalukiewicz per il contributo. (0d78ea6)

Versione 2.9.0-alpha01

7 agosto 2024

androidx.lifecycle:lifecycle-*:2.9.0-alpha01 viene rilasciato. La versione 2.9.0-alpha01 contiene questi commit.

Kotlin Multiplatform

lifecycle-testing ora è compatibile con KMP. (Iea41e)
Aggiunta del supporto per il target linuxArm64 Kotlin multipiattaforma (I139d3, b/338268719)

Nuove funzionalità

È disponibile un nuovo artefatto KMP androidx.lifecycle:lifecycle-viewmodel-testing che fornisce una classe ViewModelScenario per testare i ViewModel in isolamento, con il supporto di onCleared (tutte le piattaforme) e SavedStateHandle (solo Android). (337f68d, c9b3409, 9799a95c, b/264602919)
La creazione di un ViewModel con ViewModelProvider è ora sicura per i thread; le annotazioni @MainThread sono state rimosse. (Ifd978, b/237006831)

Modifiche all'API

Aggiungi la funzione di fabbrica CreationExtras.Key() per semplificare la creazione di oggetti CreationExtras.Key anonimi. (I970ee)
CreationExtras ora include sovraccarichi di operatori simili a map per consentire la manipolazione idiomatica dei contenuti in Kotlin. Consente l'utilizzo di in, += e + con CreationExtras. (Ib4353)
CreationExtras ora implementa i metodi equals, hashCode e toString. (Ib4353)
NewInstanceFactory è ora disponibile sui target JVM Desktop e Android. (d3d0892)
Proprietà di estensione in linea per esporre in modo sicuro l'applicazione sottostante nella versione 2.0 del linguaggio Kotlin (I39df2)

Correzioni di bug

È stato rimosso il riepilogo manuale dell'accesso alle nuove API di piattaforma, poiché questo avviene automaticamente tramite la definizione del modello API quando si utilizza R8 con AGP 7.3 o versioni successive (ad es. R8 versione 3.3) e per tutte le build quando si utilizza AGP 8.1 o versioni successive (ad es. D8 versione 8.1). I clienti che non utilizzano AGP sono invitati a eseguire l'aggiornamento alla versione 8.1 o successive di D8. Consulta questo articolo per ulteriori dettagli. (If6b4c, b/345472586)

Versione 2.8

Versione 2.8.7

30 ottobre 2024

androidx.lifecycle:lifecycle-*:2.8.7 viene rilasciato. La versione 2.8.7 contiene questi commit.

Modifiche all'API

androidx.compose.ui.platform.LocalLifecycleOwner è ora disponibile nel set di origine comune (KMP). (6a3f5b3)
lifecycle-runtime-compose: sono stati rimossi gli elementi desktop e sono stati aggiunti gli elementi -jvmStubs e -linuxx64Stubs. Nessuno di questi target è destinato all'uso, ma sono segnaposto per supportare le attività di JetBrains Compose. (6a3f5b3)

Versione 2.8.6

18 settembre 2024

androidx.lifecycle:lifecycle-*:2.8.6 viene rilasciato. La versione 2.8.6 contiene questi commit.

Correzioni di bug

L'errore Lint NullSafeMutableLiveData ha migliorato il supporto per le trasmissioni intelligenti, evitando falsi positivi. (85fed6, b/181042665)

Aggiornamenti delle dipendenze

Lifecycle Runtime Compose ora dipende da Compose Runtime 1.7.1

Versione 2.8.5

4 settembre 2024

androidx.lifecycle:lifecycle-*:2.8.5 viene rilasciato. La versione 2.8.5 contiene questi commit.

Correzioni di bug

Aggiorna le regole di ProGuard androidx.lifecycle.ReportFragment per consentire l'oscuramento . (ff898e1)

Contributo esterno

Il delegato dell'estensione SavedStateHandle.saveable ora supporta i valori null. Grazie a Roman Kalukiewicz per il contributo. (0d78ea6)

Versione 2.8.4

24 luglio 2024

androidx.lifecycle:lifecycle-*:2.8.4 viene rilasciato. La versione 2.8.4 contiene questi commit.

Correzioni di bug

LiveData.asFlow() ora gestisce correttamente i casi in cui il flusso restituito viene completato immediatamente dopo aver ricevuto un valore già impostato su LiveData (ad esempio, quando si utilizza take(1)). (I9c566)
Il completamento di Lifecycle*Effect è ora idempotente (ovvero, se onStopOrDispose è stato chiamato a causa dell'interruzione del ciclo di vita, non verrà chiamato una seconda volta al momento dello smaltimento, a meno che il ciclo di vita non torni di nuovo a STARTED). (I5f607, b/352364595)

Versione 2.8.3

July 1, 2024

androidx.lifecycle:lifecycle-*:2.8.3 viene rilasciato. La versione 2.8.3 contiene questi commit.

Correzioni di bug

È stato risolto un problema relativo alla compatibilità con le versioni precedenti di Lifecycle 2.8 con Compose 1.6.0 e versioni precedenti quando si utilizza la riduzione del codice. (aosp/3133056, b/346808608)

Versione 2.8.2

12 giugno 2024

androidx.lifecycle:lifecycle-*:2.8.2 viene rilasciato. La versione 2.8.2 contiene questi commit.

Correzioni di bug

Sono stati corretti gli errori CompositionLocal LocalLifecycleOwner not present durante l'utilizzo di Lifecycle 2.8.X con Compose 1.6.X o versioni precedenti. Ora puoi utilizzare Lifecycle 2.8.2 con qualsiasi versione di Compose senza alcuna soluzione alternativa. (aosp/3105647, b/336842920)
ViewModelProvider non avrà più arresti anomali quando vengono combinate le versioni precedenti delle dipendenze del ciclo di vita di compileOnly con le versioni 2.8 e successive, risolvendo i problemi con librerie come LeakCanary. (I80383, b/341792251)

Versione 2.8.1

29 maggio 2024

androidx.lifecycle:lifecycle-*:2.8.1 viene rilasciato. La versione 2.8.1 contiene questi commit.

Correzioni di bug

lifecycle-viewmodel-compose ora ha una sola dipendenza comune da compose-runtime, poiché è stata rimossa la dipendenza comune da compose-ui. L'elemento Android mantiene il proprio compose-ui per compatibilità. (aosp/3079334, b/339562627)
L'integrazione di saveable di ViewModel che utilizza i delegati delle proprietà ora utilizza il nome della classe come parte della chiave generata automaticamente, evitando conflitti se più classi utilizzano lo stesso SavedStateHandle. (aosp/3063463)

Versione 2.8.0

14 maggio 2024

androidx.lifecycle:lifecycle-*:2.8.0 viene rilasciato. La versione 2.8.0 contiene questi commit.

Modifiche importanti dalla versione 2.7.0

LocalLifecycleOwner è stato spostato dall'interfaccia utente di Compose a lifecycle-runtime-compose in modo che le sue API di assistenza basate su Compose possano essere utilizzate al di fuori dell'interfaccia utente di Compose.
L'elemento lifecycle-runtime-compose ora contiene le API dropUnlessResumed e dropUnlessStarted che consentono di eliminare i clic o altri eventi che si verificano anche dopo che il valore LifecycleOwner è sceso al di sotto del valore Lifecycle.State specificato. Ad esempio, questo può essere utilizzato con Navigation Compose per evitare di gestire gli eventi di clic dopo che è già iniziata una transizione a un'altra schermata: onClick: () -> Unit = dropUnlessResumed { navController.navigate(NEW_SCREEN) }

ViewModel.viewModelScope ora è un parametro del costruttore sostituibile, che ti consente di iniettare il tuo dispatcher e SupervisorJob() o di sostituire quello predefinito utilizzando backgroundScope disponibile in runTest. (I2817c, b/264598574)

class MyViewModel(
  // Make Dispatchers.Main the default, rather than Dispatchers.Main.immediate
  viewModelScope: CoroutineScope = Dispatchers.Main + SupervisorJob()
) : ViewModel(viewModelScope) {
  // Use viewModelScope as before, without any code changes
}

// Allows overriding the viewModelScope in a test
fun Test() = runTest {
  val viewModel = MyViewModel(backgroundScope)
}

ViewModel è stato riscritto in Kotlin e ora utilizza AutoClosable anziché Closeable. Ora supporta l'aggiunta di oggetti AutoCloseable con un key che consente di recuperarli tramite getCloseable().
Ora le chiamate a LifecycleStartEffect e LifecycleResumeEffect senza una chiave generano un errore, seguendo la stessa convenzione dell'API DisposableEffect di cui queste API sono il mirroring.
LiveDataReactiveStreams.toPublisher(lifecycleOwner, liveData) è stato ritirato in favore di LiveData.toPublisher(lifecycleOwner).
Le estensioni lifecycle-livedata-core-ktx kotlin sono state spostate nel modulo lifecycle-livedata-core.
NullSafeMutableLiveData è stato sottoposto a refactoring per evitare molti falsi positivi.

Compatibilità del ciclo di vita di Kotlin Multiplatform

Le API di gestione del ciclo di vita di base in Lifecycle, LifecycleOwner, LifecycleObserver, Lifecycle.State, Lifecycle.Event e LifecycleRegistry ora vengono fornite in elementi compatibili con Kotlin Multiplatform.

Artefatti interessati:

lifecycle-common sposta la maggior parte delle API in common e supporta jvm e iOS oltre ad Android.
lifecycle-runtime sposta la maggior parte delle API in common e supporta jvm e iOS oltre ad Android.
lifecycle-runtime-ktx ora è vuoto e tutte le API sono state spostate in lifecycle-runtime.
lifecycle-runtime-compose sposta tutte le API in common e rilascia un artifact Android, in linea con il supporto multipiattaforma di androidx.compose.

Compatibilità con Kotlin Multiplatform di ViewModel

L'elemento lifecycle-viewmodel e API come ViewModel, ViewModelStore, ViewModelStoreOwner e ViewModelProvider ora vengono forniti in elementi compatibili con Kotlin Multiplatform.

Per supportare questa modifica, i metodi come quelli in ViewModelProvider che accettavano un java.lang.Class<T> ora hanno un metodo equivalente che accetta un kotlin.reflect.KClass<T>.

La compatibilità binaria su Android è stata mantenuta, ma ci sono alcune modifiche significative se si confronta l'API Android con l'API comune:

La creazione di un'istanza ViewModelProvider ora viene eseguita tramite i metodi ViewModelProvider.create() anziché chiamando direttamente il relativo costruttore.
ViewModelProvider.NewInstanceFactory e ViewModelProvider.AndroidViewModelFactory sono disponibili solo su Android.
- Per le fabbriche personalizzate è consigliabile estendere ViewModelProvider.Factory e utilizzare il metodo create che accetta un CreationExtras o utilizzare il DSL Kotlin viewModelFactory.
L'utilizzo di ViewModelProvider senza una factory personalizzata su piattaforme non JVM comporterà un UnsupportedOperationException. Sulle piattaforme JVM, la compatibilità viene preservata utilizzando il costruttore ViewModel senza argomenti se non viene fornita una fabbrica personalizzata.
viewModelScope eseguirà il fallback a un EmptyCoroutineContext nelle piattaforme in cui Dispatchers.Main non è disponibile (ad es. Linux).

Artefatti interessati:

lifecycle-viewmodel sposta la maggior parte delle API in common e supporta jvm e iOS oltre ad Android.
lifecycle-viewmodel-ktx ora è vuoto e tutte le API sono state spostate in lifecycle-viewmodel.
lifecycle-viewmodel-compose sposta tutte le API in common e rilascia un artifact Android, in linea con il supporto multipiattaforma di androidx.compose.

Modifiche al comportamento

InitializerViewModelFactory (inclusa la funzione di creazione di viewModelFactory) ora genera un IllegalArgumentException se è già stato aggiunto un initializer con lo stesso clazz: KClass<VM : ViewModel>. (Ic3a36)

Problemi noti

lifecycle-*:2.8.0 richiede una versione minima di Compose 1.7.0-alpha05 (b/336842920).

Versione 2.8.0-rc01

1° maggio 2024

androidx.lifecycle:lifecycle-*:2.8.0-rc01 viene rilasciato. La versione 2.8.0-rc01 contiene questi commit.

Correzioni di bug

Risolto un problema per cui il profilo di riferimento per le classi lifecycle-common non era pacchettizzato correttamente. Ora sono pacchettizzati nell'AAR lifecycle-runtime. (aosp/3038274, b/322382422)
È stata corretta una modifica non intenzionale dell'ordine in cui vengono cancellate le istanze AutoCloseable associate a un ViewModel. È stato ripristinato l'ordine precedente di addCloseable(String, AutoCloseable), addClosable(AutoCloseable) e onCleared(). (aosp/3041632)
Migliorare il comportamento di creazione predefinito per viewModelScope per gli ambienti desktop nativi e JVM. (aosp/3039221)

Contributo esterno

Grazie a Victor Kropp per aver migliorato il controllo del thread principale su JVM Desktop. (aosp/3037116)

Versione 2.8.0-beta01

17 aprile 2024

androidx.lifecycle:lifecycle-*:2.8.0-beta01 viene rilasciato. La versione 2.8.0-beta01 contiene questi commit.

Nuove funzionalità

L'elemento lifecycle-runtime-compose è ora compatibile con Kotlin Multiplatform, il codice viene spostato in common e viene fornito un elemento Android, in linea con il supporto multipiattaforma per androidx.compose. (If7a71, I4f4a0, b/331769623)

Versione 2.8.0-alpha04

3 aprile 2024

androidx.lifecycle:lifecycle-*:2.8.0-alpha04 viene rilasciato. La versione 2.8.0-alpha04 contiene questi commit.

Nuove funzionalità

L'elemento lifecycle-viewmodel-compose è ora compatibile con Kotlin Multiplatform, il codice viene spostato in common e viene fornito un elemento Android, in linea con il supporto multipiattaforma di androidx.compose. Per adattarsi a questa modifica, il metodo Composable viewModel ora accetta un KClass oltre a un java.lang.Class. (b/330323282)

Correzioni di bug

NullSafeMutableLiveData è stato sottoposto a refactoring per evitare molti falsi positivi. (I2d8c1, Iafb18, I03463, I7ecef)

Aggiornamento delle dipendenze

L'elemento lifecycle-viewmodel-compose ora dipende da Compose 1.6.0.
Il ciclo di vita ora dipende da Profile Installer 1.3.1.

Versione 2.8.0-alpha03

20 marzo 2024

androidx.lifecycle:lifecycle-*:2.8.0-alpha03 viene rilasciato. La versione 2.8.0-alpha03 contiene questi commit.

Nuove funzionalità

class MyViewModel(
  // Make Dispatchers.Main the default, rather than Dispatchers.Main.immediate
  viewModelScope: CoroutineScope = Dispatchers.Main + SupervisorJob()
) : ViewModel(viewModelScope) {
  // Use viewModelScope as before, without any code changes
}

// Allows overriding the viewModelScope in a test
fun Test() = runTest {
  val viewModel = MyViewModel(backgroundScope)
}

Compatibilità con Kotlin Multiplatform

L'elemento lifecycle-viewmodel e API come ViewModel, ViewModelStore, ViewModelStoreOwner e ViewModelProvider ora vengono forniti in elementi compatibili con Kotlin Multiplatform. (b/214568825)

Per supportare questa modifica, i metodi come quelli in ViewModelProvider che accettavano un java.lang.Class<T> ora hanno un metodo equivalente che accetta un kotlin.reflect.KClass<T>.

La compatibilità binaria su Android è stata mantenuta, ma ci sono alcune modifiche significative se si confronta l'API Android con l'API comune:

La creazione di un'istanza ViewModelProvider ora viene eseguita tramite i metodi ViewModelProvider.create() anziché chiamando direttamente il relativo costruttore.
ViewModelProvider.NewInstanceFactory e ViewModelProvider.AndroidViewModelFactory sono disponibili solo su Android.
- Per le fabbriche personalizzate è consigliabile estendere ViewModelProvider.Factory e utilizzare il metodo create che accetta un CreationExtras o utilizzare il DSL Kotlin viewModelFactory.
L'utilizzo di ViewModelProvider senza una factory personalizzata su piattaforme non JVM comporterà un UnsupportedOperationException. Sulle piattaforme JVM, la compatibilità viene preservata utilizzando il costruttore ViewModel senza argomenti se non viene fornita una fabbrica personalizzata.
viewModelScope eseguirà il fallback a un EmptyCoroutineContext nelle piattaforme in cui Dispatchers.Main non è disponibile (ad es. Linux).

Modifiche al comportamento

InitializerViewModelFactory (inclusa la funzione di creazione di viewModelFactory) ora genera un IllegalArgumentException se è già stato aggiunto un initializer con lo stesso clazz: KClass<VM : ViewModel>. (Ic3a36)

Correzioni di bug

ViewModel.getCloseable ora gestisce le chiavi duplicate: se a key è già associata una risorsa AutoCloseable, la vecchia risorsa verrà sostituita e chiusa immediatamente. (Ibeb67)
L'accesso al viewModelScope di un ViewModel è ora a prova di thread. (If4766, b/322407038)

Contributo esterno

LocalLifecycleOwner è passato dall'interfaccia utente di Compose a lifecycle-runtime-compose in modo che le sue API di assistenza basate su Compose possano essere utilizzate al di fuori dell'interfaccia utente di Compose. Grazie a Jake Wharton per il contributo. (I6c41b, b/328263448)

Versione 2.8.0-alpha02

21 febbraio 2024

androidx.lifecycle:lifecycle-*:2.8.0-alpha02 viene rilasciato. La versione 2.8.0-alpha02 contiene questi commit.

Nuove funzionalità

Sono state aggiunte le API dropUnlessResumed e dropUnlessStarted che consentono di eliminare i clic o altri eventi che si verificano anche dopo che il valore LifecycleOwner è sceso al di sotto del valore Lifecycle.State specificato. Ad esempio, questo può essere utilizzato con Navigation Compose per evitare di gestire gli eventi di clic dopo che è già iniziata una transizione a un'altra schermata: onClick: () -> Unit = dropUnlessResumed { navController.navigate(NEW_SCREEN) } (Icba83, b/317230685)

Conversioni Kotlin

ViewModel ora è scritto in Kotlin (I16f26, b/214568825)
Le estensioni lifecycle-viewmodel-ktx kotlin sono state spostate nel modulo del ciclo di vita di base. (Id787b, b/274800183)
Le estensioni lifecycle-runtime-ktx kotlin sono state spostate nel modulo del ciclo di vita di base. (Ic3686, b/274800183)
Le estensioni lifecycle-livedata-core-ktx kotlin sono state spostate nel modulo del ciclo di vita di base. (I54a3d, b/274800183)

Compatibilità con Kotlin Multiplatform

Le API di gestione del ciclo di vita di base in Lifecycle, LifecycleOwner, LifecycleObserver, Lifecycle.State, Lifecycle.Event e LifecycleRegistry ora vengono fornite in elementi compatibili con Kotlin Multiplatform. (b/317249252)

Modifiche all'API

Ora le chiamate a LifecycleStartEffect e LifecycleResumeEffect senza una chiave generano un errore, seguendo la stessa convenzione dell'API DisposableEffect di cui queste API sono il mirroring. (Ib0e0c, b/323518079)
ViewModel ora utilizza AutoCloseable anziché Closeable. Si tratta di una modifica compatibile con le versioni precedenti. (I27f8e, b/214568825)
LiveDataReactiveStreams.toPublisher(lifecycleOwner, liveData) è stato ritirato in favore di LiveData.toPublisher(lifecycleOwner). (Iabe29, b/262623005)

Contributo esterno

Grazie a Ivan Matkov di JetBrains per aver contribuito al trasferimento di Lifecycle a Kotlin Multiplatform. (aosp/2926690, I0c5ac, If445d)

Versione 2.8.0-alpha01

24 gennaio 2024

androidx.lifecycle:lifecycle-*:2.8.0-alpha01 viene rilasciato. La versione 2.8.0-alpha01 contiene questi commit.

Nuove funzionalità

ViewModel ora supporta l'aggiunta di oggetti Closeable con un key che consente di recuperarli tramite getCloseable(). (I3cf63)

Versione 2.7

Versione 2.7.0

10 gennaio 2024

androidx.lifecycle:lifecycle-*:2.7.0 viene rilasciato. La versione 2.7.0 contiene questi commit.

Modifiche importanti dalla versione 2.6.0

TestLifecycleOwner ora include una funzione di sospensione setCurrentState() che garantisce il completamento della modifica dello stato e di tutti i callback LifecycleObserver prima del ritorno. In particolare, a differenza dell'impostazione diretta della proprietà currentState, non viene utilizzato runBlocking, il che lo rende sicuro da utilizzare all'interno di una coroutine come quella fornita da runTest.
Le estensioni LiveData di map e switchMap ora rispecchiano il comportamento di distinctUntilChanged: se LiveData ha un value impostato, la funzione map/switchMap verrà chiamata immediatamente per compilare il value del LiveData restituito. In questo modo, il valore iniziale verrà impostato nell'ambito della prima composizione (se utilizzato con observeAsState()), ma il comportamento dell'osservazione non cambierà: i valori aggiornati dell'origine LiveData verranno applicati solo quando inizierai a osservare LiveData.
Questa release corregge un problema per cui SavedStateHandle non ripristinava correttamente le classi Parcelable personalizzate dopo l'interruzione e la successiva creazione del processo. A causa delle informazioni sul tipo perse dal framework Android, gli array di Parcelable personalizzati richiedono un lavoro aggiuntivo (creazione manuale di un array di tipo corretto) e la documentazione su get, getLiveData e getStateFlow ora indica specificamente questa limitazione.
Le regole keep di ProGuard associate a LifecycleObserver sono state rimosse. Ciò significa che il codice protetto che vuole utilizzare le API tramite la riflessione (ad esempio l'annotazione @OnLifecycleEvent da tempo deprecata) dovrà fornire le proprie regole di conservazione per il caso d'uso specifico.

Osservabilità degli eventi del ciclo di vita

In alternativa all'utilizzo di un LifecycleEventObserver, ora puoi osservare un Flow di Lifecycle.Event tramite il metodo di estensione Lifecycle.asFlow().
Ora gli utenti di Jetpack Compose possono utilizzare LifecycleEventEffect per eseguire gli effetti collaterali di Compose in base a Lifecycle.Event.

@Composable
fun HomeScreen(viewModel: HomeViewModel = viewModel()) {
  LifecycleEventEffect(Lifecycle.Event.ON_RESUME) {
    viewModel.refreshData()
  }
  // …
}

Gli utenti di Jetpack Compose possono utilizzare LifecycleStartEffect e LifecycleResumeEffect per gestire coppie di eventi, rispettivamente da iniziato a interrotto e da ripreso a messo in pausa. Questa API rispecchia quella disponibile in DisposableEffect ed è adatta ai casi in cui la modifica apportata quando lo stato aumenta debba essere annullata quando si riduce.

fun HomeScreen(viewModel: HomeViewModel = viewModel()) {
  LifecycleStartEffect(viewModel) {
    val timeTracking = viewModel.startTrackingTimeOnScreen()
    onStopOrDispose {
      timeTracking.stopTrackingTimeOnScreen()
    }
  }
  // …
}

Per saperne di più, consulta Eseguire codice sugli eventi del ciclo di vita.

Osservabilità dello stato del ciclo di vita

Ora il Lifecycle.State corrente può essere osservato tramite la proprietà Lifecycle.currentStateFlow, che restituisce un StateFlow in cui value è il Lifecycle.State corrente.
Gli utenti di Jetpack Compose possono utilizzare l'estensione Lifecycle.currentStateAsState() per esporre direttamente Lifecycle.State come Compose State. È equivalente (e un'alternativa più breve) a lifecycle.currentStateFlow.collectAsState().

Per ulteriori informazioni, consulta la sezione Raccogliere lo stato del ciclo di vita con i flussi.

Versione 2.7.0-rc02

13 dicembre 2023

androidx.lifecycle:lifecycle-*:2.7.0-rc02 viene rilasciato. La versione 2.7.0-rc02 contiene questi commit.

Correzioni di bug

È stato risolto un problema per cui SavedStateHandle non ripristinava correttamente le classi Parcelable personalizzate dopo l'interruzione e la ricreazione del processo. A causa delle informazioni sul tipo perse dal framework Android, gli array di Parcelable personalizzati richiedono un lavoro aggiuntivo (creazione manuale di un array di tipo corretto) e la documentazione su get, getLiveData e getStateFlow ora indica specificamente questa limitazione. (I0b55a)

Versione 2.7.0-rc01

15 novembre 2023

androidx.lifecycle:lifecycle-*:2.7.0-rc01 viene rilasciato. La versione 2.7.0-rc01 contiene questi commit.

Correzioni di bug

LifecycleStartEffect e LifecycleResumeEffect ora eliminano e ricreano correttamente il blocco dell'effetto se LifecycleOwner viene modificato. (Ia25c6)

Versione 2.7.0-beta01

1° novembre 2023

androidx.lifecycle:lifecycle-*:2.7.0-beta01 viene rilasciato senza modifiche. La versione 2.7.0-beta01 contiene questi commit.

Un aggiornamento della versione beta, senza modifiche sostanziali a questa versione di release.

Versione 2.7.0-alpha03

18 ottobre 2023

androidx.lifecycle:lifecycle-*:2.7.0-alpha03 viene rilasciato. La versione 2.7.0-alpha03 contiene questi commit.

Nuove funzionalità

lifecycle-runtime-testing ora contiene un nuovo controllo Lint per evitare di impostare il Lifecycle.State del TestLifecycleOwner utilizzando il campo currentState all'interno di una coroutine. Il controllo Lint ora suggerisce la sospensione setCurrentState che consente di impostare Lifecycle.State senza bloccare. (Icf728, b/297880630)

Correzioni di bug

È stato risolto un problema con LiveData.switchMap per cui il ritorno della stessa istanza LiveData sia nella chiamata iniziale che in una chiamata successiva impediva l'aggiunta dell'istanza LiveData come origine. (Ibedcba7)

Versione 2.7.0-alpha02

6 settembre 2023

androidx.lifecycle:lifecycle-*:2.7.0-alpha02 viene rilasciato. La versione 2.7.0-alpha02 contiene questi commit.

Nuove funzionalità

TestLifecycleOwner ora include la funzione di sospensione setCurrentState() per offrire agli utenti la possibilità di utilizzare TestLifecycleOwner all'interno di una coroutine, ad esempio quella fornita da runTest. (I329de, b/259344129)

Modifiche all'API

Tutti i file dei moduli lifecycle-livedata-ktx sono stati spostati nel modulo lifecycle-livedata principale. (I10c6f, b/274800183)

Modifiche al comportamento

Le estensioni LiveData.map() e LiveData.switchMap() ora impostano il value del LiveData restituito se al LiveData precedente è stato impostato un valore, garantendo che l'utilizzo del LiveData risultante in Jetpack Compose abbia lo stato corretto nella composizione iniziale. (I91d2b, b/269479952)
Ora addCloseable() di ViewModel chiude immediatamente Closeable se ViewModel ha già ricevuto una chiamata a onCleared(). (I4712e, b/280294730)

Correzioni di bug

Da Lifecycle 2.6.2: è stato risolto un problema per cui SavedStateHandle non veniva ripristinato correttamente dopo l'interruzione del processo se lo stato veniva ripristinato, save() veniva chiamato senza salvare effettivamente lo stato nel SavedStateRegistry principale e lo stato veniva ripristinato di nuovo. In questo modo viene corretta l'interazione tra rememberSaveable e NavHost di Navigation Compose. (aosp/2729289)

Versione 2.7.0-alpha01

26 luglio 2023

androidx.lifecycle:lifecycle-*:2.7.0-alpha01 viene rilasciato. La versione 2.7.0-alpha01 contiene questi commit.

Modifiche all'API

Lifecycle.State ora è osservabile tramite Lifecycle.currentStateFlow, che restituisce un StateFlow in cui value è l'attuale Lifecycle.State. (Ib212d, b/209684871)
Ora i Lifecycle.Event possono essere osservati come Flow con Lifecycle.asFlow(). (If2c0f, b/176311030)
È stata aggiunta l'API LifecycleResumeEffect per eseguire comandi SideEffect di composizione in base ai callback degli eventi Lifecycle.Event.ON_RESUME e Lifecycle.Event.ON_PAUSE. (I60386, b/235529345)
È stata aggiunta l'API LifecycleStartEffect per eseguire SideEffect di composizione in base ai callback degli eventi Lifecycle.Event.ON_START e Lifecycle.Event.ON_STOP. (I5a8d1, b/235529345)
L'API LifecycleEventEffect è stata aggiunta per eseguire SideEffect di composizione in base a Lifecycle.Event. (Ic9794, b/235529345)
È stata aggiunta l'estensione Lifecycle.collectAsState() per esporre direttamente Lifecycle.State come Scrivi State. È equivalente (e un'alternativa più breve) a lifecycle.currentStateFlow.collectAsState(). (I11015, b/235529345)

Correzioni di bug

L'estensione LiveData.distinctUntilChanged() ora imposta il value del LiveData restituito se al LiveData precedente è stato impostato un valore. Questo non cambia il comportamento dell'osservazione: i valori aggiornati dell'origine LiveData verranno applicati solo quando inizierai a osservare il LiveData restituito da distinctUntilChanged(). (Ib482f)
Le regole keep di ProGuard associate a LifecycleObserver sono state rimosse. Ciò significa che il codice protetto che vuole utilizzare le API tramite la riflessione dovrà fornire le proprie regole di conservazione per il caso d'uso specifico. (Ia12fd)

Versione 2.6

Versione 2.6.2

6 settembre 2023

androidx.lifecycle:lifecycle-*:2.6.2 viene rilasciato. La versione 2.6.2 contiene questi commit.

Correzioni di bug

È stato risolto un problema per cui SavedStateHandle non veniva ripristinato correttamente dopo l'interruzione del processo se lo stato veniva ripristinato, save() veniva chiamato senza salvare effettivamente lo stato in SavedStateRegistry principale e lo stato veniva ripristinato di nuovo. In questo modo viene corretta l'interazione tra rememberSaveable e NavHost di Navigation Compose. (aosp/2729289)

Versione 2.6.1

22 marzo 2023

androidx.lifecycle:lifecycle-*:2.6.1 viene rilasciato. La versione 2.6.1 contiene questi commit.

Aggiornamenti delle dipendenze

lifecycle-viewmodel-savedstate ora dipende da SavedState 1.2.1. (cd7251)
Il ciclo di vita ora dipende da ProfileInstaller 1.3.0. (f9d30b)

Versione 2.6.0

8 marzo 2023

androidx.lifecycle:lifecycle-*:2.6.0 viene rilasciato. La versione 2.6.0 contiene questi commit.

Modifiche importanti dalla versione 2.5.0

LiveData ora include una nuova proprietà isInitialized che indica se è stato impostato un valore esplicito su LiveData, consentendo di distinguere tra liveData.value che restituisce null perché non è stato impostato alcun valore o un valore null esplicito.
MediatorLiveData ora include un costruttore per impostare un valore iniziale.
È stata aggiunta una nuova estensione per StateFlow e Flow di collectAsStateWithLifecycle() che raccoglie i dati dai flussi e ne rappresenta il valore più recente come stato di composizione in modo consapevole del ciclo di vita.
I metodi Lifecycle.launchWhenX e Lifecycle.whenX sono stati ritirati perché l'utilizzo di un gestore di interruzioni può comportare spreco di risorse in alcuni casi. È consigliabile utilizzare Lifecycle.repeatOnLifecycle. Per ulteriori informazioni sulla sospensione una tantum del lavoro, consulta questa spiegazione sul motivo per cui questa operazione non è sicura.
Conversione in Kotlin: un numero elevato di classi Lifecycle è stato convertito in Kotlin. Tutti i corsi convertiti mantengono la compatibilità binaria con le versioni precedenti. Le seguenti classi presentano modifiche incompatibili con il codice sorgente per le classi scritte in Kotlin: ViewTreeLifecycleOwner, LiveDataReactiveStreams, HasDefaultViewModelProviderFactory, ViewTreeViewModelStoreOwner, Transformations, ViewModelStoreOwner, LifecycleOwner

La tabella seguente fornisce le conversioni di origine per la nuova versione del ciclo di vita.

Ciclo di vita 2.5	Ciclo di vita 2.5 (KTX)	Ciclo di vita 2.6
`Transformations.switchMap(liveData) {...}`	`liveData.switchMap {...}`	`liveData.switchMap {...}`
`Transformations.map(liveData) {...}`	`liveData.map {...}`	`liveData.map {...}`
`Transformations.distinctUntilChanged(liveData) {...}`	`liveData.distinctUntilChanged{...}`	`liveData.distinctUntilChanged{...}`
`LiveDataReactiveStreams.fromPublisher(publisher)`	`publisher.toLiveData()`	`publisher.toLiveData()`
`LiveDataReactiveStreams.toPublisher(lifecycleOwner, liveData)`	`liveData.toPublisher(lifecycleOwner)`	`liveData.toPublisher(lifecycleOwner)`
`override fun getDefaultViewModelProviderFactory(): ViewModelProvider.Factory = factory`	`override fun getDefaultViewModelProviderFactory(): ViewModelProvider.Factory = factory`	`override val defaultViewModelProviderFactory = factory`
`override fun getDefaultViewModelCreationExtras(): CreationExtras = extras`	`override fun getDefaultViewModelCreationExtras(): CreationExtras = extras`	`override val defaultViewModelProviderCreationExtras = extras`
`ViewTreeLifecycleOwner.set(view, owner)`	`ViewTreeLifecycleOwner.set(view, owner)`	`view.setViewTreeLifecycleOwner(owner)`
`ViewTreeLifecycleOwner.get(view)`	`view.findViewTreeLifecycleOwner()`	`view.findViewTreeLifecycleOwner()`
`override fun getViewModelStore(): ViewModelStore = store`	`override fun getViewModelStore(): ViewModelStore = store`	`override val viewModelStore: ViewModelStore = store`
`override fun getLifecycle(): Lifecycle = registry`	`override fun getLifecycle(): Lifecycle = registry`	`override val lifecycle: Lifecycle get() = registry`

La nullabilità del metodo onChanged di un Observer creato in Kotlin ora corrisponde a quella del tipo generico. Se vuoi che Observer.onChanged() accetti un tipo nullable, devi creare un'istanza di Observer con un tipo nullable.
Anche queste classi sono state convertite in Kotlin, ma rimangono compatibili con il codice sorgente: DefaultLifecycleObserver, LifecycleEventObserver, Lifecycle, LifecycleRegistry, LifecycleObserver, ViewModelStore, AndroidViewModel, AbstractSavedStateViewModelFactory, LifecycleService, ServiceLifecycleDispatcher e ProcessLifecycleOwner

Versione 2.6.0-rc01

22 febbraio 2023

androidx.lifecycle:lifecycle-*:2.6.0-rc01 viene rilasciato. La versione 2.6.0-rc01 contiene questi commit.

Correzioni di bug

L'estensione LiveData.distinctUntilChanged() ora imposta il value del LiveData restituito se al LiveData precedente è stato impostato un valore. Questo non cambia il comportamento dell'osservazione: i valori aggiornati dell'origine LiveData verranno applicati solo quando inizierai a osservare il LiveData restituito da distinctUntilChanged(). (Ib482f)

Versione 2.6.0-beta01

8 febbraio 2023

androidx.lifecycle:lifecycle-*:2.6.0-beta01 viene rilasciato. La versione 2.6.0-beta01 contiene questi commit.

Conversioni Kotlin

LifecycleOwner è ora scritto in Kotlin. Si tratta di una modifica incompatibile con il codice sorgente per le classi scritte in Kotlin: ora devono sostituire la proprietà lifecycle anziché implementare la precedente funzione getLifecycle(). (I75b4b, b/240298691)
ViewModelStoreOwner è ora in Kotlin. Si tratta di una modifica incompatibile con il codice sorgente per le classi scritte in Kotlin: ora devono sostituire la proprietà viewModelStore anziché implementare la precedente funzione getViewModelStore(). (I86409, b/240298691)
L'estensione Kotlin su LifecycleOwner che fornisce il campo lifecycleScope è stata spostata nell'elemento lifecycle-common da lifecycle-runtime-ktx. (I41d78, b/240298691)
L'estensione Kotlin su Lifecycle che fornisce il campo coroutineScope è stata spostata nell'elemento lifecycle-common da lifecycle-runtime-ktx. (Iabb91, b/240298691)

Versione 2.6.0-alpha05

25 gennaio 2023

androidx.lifecycle:lifecycle-*:2.6.0-alpha05 viene rilasciato. La versione 2.6.0-alpha05 contiene questi commit.

Conversioni Kotlin

Transformations è ora scritto in Kotlin. Si tratta di una modifica incompatibile con il codice sorgente per le classi scritte in Kotlin che utilizzavano direttamente la sintassi come Transformations.map. Ora il codice Kotlin deve utilizzare la sintassi del metodo di estensione Kotlin che in precedenza era disponibile solo con lifecycle-livedata-ktx. Quando utilizzi il linguaggio di programmazione Java, le versioni di questi metodi che accettano un metodo androidx.arch.core.util.Function sono ritirate e sostituite con le versioni che accettano un Function1 Kotlin. Questa modifica mantiene la compatibilità binaria. (I8e14f)
ViewTreeViewModelStoreOwner è ora scritto in Kotlin. Si tratta di una modifica non compatibile con il codice sorgente per le classi scritte in Kotlin: ora devi importare e utilizzare direttamente i metodi di estensione Kotlin su View di androidx.lifecycle.setViewTreeViewModelStoreOwner e androidx.lifecycle.findViewTreeViewModelStoreOwner per impostare e trovare un proprietario impostato in precedenza. È compatibile con i binari e rimane compatibile con il codice sorgente per le implementazioni scritte nel linguaggio di programmazione Java. (Ia06d8, Ib22d8, b/240298691)
L'interfaccia HasDefaultViewModelProviderFactory è ora scritta in Kotlin. Si tratta di una modifica incompatibile con il codice sorgente per le classi scritte in Kotlin: ora devono sostituire le proprietà defaultViewModelProviderFactory e defaultViewModelCreationExtras anziché implementare le funzioni corrispondenti precedenti. (Iaed9c, b/240298691)
Observer è ora scritto in Kotlin. Il metodo onChanged() ora utilizza il nome value per il parametro. (Iffef2, I4995e, b/240298691)
AndroidViewModel, AbstractSavedStateViewModelFactory, LifecycleService, ServiceLifecycleDispatcher e ProcessLifecycleOwner ora sono scritti in Kotlin (I2e771, Ibae40, I160d7, I08884, I1cda7, b/240298691)

Versione 2.6.0-alpha04

11 gennaio 2023

androidx.lifecycle:lifecycle-*:2.6.0-alpha04 viene rilasciato. La versione 2.6.0-alpha04 contiene questi commit.

Nuove funzionalità

LiveData ora include una nuova proprietà isInitialized che indica se è stato impostato un valore esplicito su LiveData, consentendo di distinguere tra liveData.value che restituisce null perché non è stato impostato alcun valore o un valore null esplicito. (Ibd018)

Modifiche all'API

Le API collectAsStateWithLifecycle() di lifecycle-runtime-compose non sono più in stato sperimentale. (I09d42, b/258835424)
I metodi Lifecycle.launchWhenX e Lifecycle.whenX sono stati ritirati perché l'utilizzo di un gestore di interruzioni può comportare spreco di risorse in alcuni casi. È consigliabile utilizzare Lifecycle.repeatOnLifecycle. (Iafc54, b/248302832)

Conversioni Kotlin

ViewTreeLifecycleOwner è ora scritto in Kotlin. Si tratta di una modifica non compatibile con il codice sorgente per le classi scritte in Kotlin: ora devi importare e utilizzare direttamente i metodi di estensione Kotlin su View di androidx.lifecycle.setViewTreeLifecycleOwner e androidx.lifecycle.findViewTreeLifecycleOwner per impostare e trovare un proprietario impostato in precedenza. Questa estensione sostituisce la precedente estensione Kotlin in lifecycle-runtime-ktx. È compatibile con i binari e rimane compatibile con il codice sorgente per le implementazioni scritte nel linguaggio di programmazione Java. (I8a77a, I5234e, b/240298691)
LiveDataReactiveStreams è ora scritto in Kotlin. Le estensioni Kotlin precedentemente in lifecycle-reactivestreams-ktx sono state spostate nel modulo lifecycle-reactivestreams e sono diventate la piattaforma principale per il codice scritto in Kotlin. Si tratta di una modifica incompatibile con il codice sorgente per il codice scritto in Kotlin se non utilizzavi già le API dei metodi di estensione Kotlin. (I2b1b9, I95d22, b/240298691)
DefaultLifecycleObserver, LifecycleEventObserver, Lifecycle, LifecycleRegistry, LifecycleObserver e ViewModelStore ora sono scritti in Kotlin (Iadffd, (I60034, I8c52c, I9593d, I01fe1, I59a23, b/240298691)

Correzioni di bug

SavedStateHandle non si arresta più in modo anomalo con un ClassCastException quando viene chiamato get() con il tipo di classe errato. (I6ae7c)

Versione 2.6.0-alpha03

24 ottobre 2022

androidx.lifecycle:lifecycle-*:2.6.0-alpha03 viene rilasciato. La versione 2.6.0-alpha03 contiene questi commit.

Correzioni di bug

È stato risolto un problema relativo ai vincoli tra diversi moduli del ciclo di vita che non funzionavano come previsto. (I18d0d, b/249686765)
Gli errori generati da LifecycleRegistry.moveToState() ora includono un messaggio di errore più utile che informa gli sviluppatori del componente che causa l'errore. (Idf4b2, b/244910446)

Versione 2.6.0-alpha02

7 settembre 2022

androidx.lifecycle:lifecycle-*:2.6.0-alpha02 viene rilasciato. La versione 2.6.0-alpha02 contiene questi commit.

Modifiche all'API

MediatorLiveData ora include un costruttore per impostare un valore iniziale. (Ib6cc5, b/151244085)

Correzioni di bug

Gli elementi Lifecycle ora includono limitazioni che assicurano che tutti gli elementi del ciclo di vita interdipendenti utilizzino la stessa versione, eseguendo automaticamente l'upgrade di altre dipendenze quando ne viene eseguito uno. b/242871265
FlowLiveData.asFlow() ora crea un callbackFlow anziché utilizzare la propria implementazione di Channel per garantire la sicurezza del thread e la conservazione del contesto. (I4a8b2, b/200596935)
La funzione asLiveData di FlowLiveData ora manterrà il valore iniziale di un StateFlow durante la creazione del nuovo oggetto LiveData. (I3f530, b/157380488)
Da Lifecycle 2.5.1: le implementazioni personalizzate di AndroidViewModelFactory ora chiamano correttamente la funzione create(modelClass) quando si utilizza il costruttore con stato con Lifecycle 2.4 e versioni successive (I5b315, b/238011621)

Versione 2.6.0-alpha01

29 giugno 2022

androidx.lifecycle:lifecycle-*:2.6.0-alpha01 viene rilasciato. La versione 2.6.0-alpha01 contiene questi commit.

Nuove funzionalità

È stata aggiunta una nuova estensione per StateFlow e Flow di collectAsStateWithLifecycle che raccoglie i dati dai flussi e ne rappresenta il valore più recente come stato di composizione in modo consapevole del ciclo di vita. Il flusso viene raccolto e la nuova emissione viene impostata sul valore dello stato quando il ciclo di vita è almeno in un determinato Lifecycle.State. Quando il ciclo di vita scende al di sotto di Lifecycle.State, la raccolta del flusso si interrompe e il valore dello stato non viene aggiornato. (I1856e, b/230557927)

Versione 2.5

Versione 2.5.1

27 luglio 2022

androidx.lifecycle:lifecycle-*:2.5.1 viene rilasciato. La versione 2.5.1 contiene questi commit.

Correzioni di bug

Le implementazioni personalizzate di AndroidViewModelFactory ora chiamano correttamente la funzione create(modelClass) quando viene utilizzato il costruttore AndroidViewModelFactory con stato con Lifecycle 2.4 e versioni successive. (I5b315, b/238011621)

Versione 2.5.0

29 giugno 2022

androidx.lifecycle:lifecycle-*:2.5.0 viene rilasciato. La versione 2.5.0 contiene questi commit.

Modifiche importanti dalla versione 2.4.0

SavedStateHandle ora offre un'API getStateFlow() che restituisce un StateFlow di Kotlin per il monitoraggio delle variazioni di valore come alternativa all'utilizzo di LiveData.

ViewModel CreationExtras: quando scrivi un ViewModelProvider.Factory personalizzato, non è più necessario estendere AndroidViewModelFactory o AbstractSavedStateViewModelFactory per ottenere l'accesso a Application o SavedStateHandle, rispettivamente. Questi campi vengono invece forniti a ogni sottoclasse ViewModelProvider.Factory come CreationExtras tramite il nuovo sovraccarico di create: create(Class<T>, CreationExtras). Questi extra vengono forniti automaticamente dall'attività o dal frammento quando utilizzi rispettivamente Attività 1.5.0 e Frammento 1.5.0.

class CustomFactory : ViewModelProvider.Factory {
    override fun <T : ViewModel> create(modelClass: Class<T>, extras: CreationExtras): T {
        return when (modelClass) {
            HomeViewModel::class -> {
                // Get the Application object from extras
                val application = checkNotNull(extras[ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY])
                // Pass it directly to HomeViewModel
                HomeViewModel(application)
            }
            DetailViewModel::class -> {
                // Create a SavedStateHandle for this ViewModel from extras
                val savedStateHandle = extras.createSavedStateHandle()
                DetailViewModel(savedStateHandle)
            }
            else -> throw IllegalArgumentException("Unknown class $modelClass")
        } as T
    }
}

lifecycle-viewmodel ora fornisce un DSL viewModelFactory Kotlin che ti consente di definire ViewModelProvider.Factory in termini di uno o più inizializzatori lambda, uno per ogni classe ViewModel specifica supportata dalla tua fabbrica personalizzata, utilizzando CreationExtras come origine dati principale.

val customFactory = viewModelFactory {
    // The return type of the lambda automatically sets what class this lambda handles
    initializer {
        // Get the Application object from extras provided to the lambda
        val application = checkNotNull(get(ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY))
        HomeViewModel(application)
    }
    initializer {
        val savedStateHandle = createSavedStateHandle()
        DetailViewModel(savedStateHandle)
    }
}

lifecycle-viewmodel-compose ora offre un'API viewModel() che utilizza una factory lambda per creare un'istanza ViewModel senza richiedere la creazione di un ViewModelProvider.Factory personalizzato.

// Within a @Composable, you can now skip writing a custom Factory
// and instead write a lambda to do the initialization of your ViewModel
val detailViewModel = viewModel {
  // This lambda is only called the first time the ViewModel is created
  // and all CreationExtras are available inside the lambda
  val savedStateHandle = createSavedStateHandle()
  DetailViewModel(savedStateHandle)
}

Integrazione di Compose Saver in SavedStateHandle: l'artifact lifecycle-viewmodel-compose ora contiene nuove API sperimentali in SavedStateHandle.saveable che consentono un comportamento simile a rememberSaveable supportato dal SavedStateHandle di un ViewModel.
```
class ListScreenViewModel(handle: SavedStateHandle): ViewModel() {
    // This value survives both configuration changes and process death and recreation
    val editMode by handle.saveable { mutableStateOf(false) }
}
```

È stata aggiunta un'API addCloseable() e un nuovo sovraccarico del costruttore che ti consentono di aggiungere uno o più oggetti Closeable al ViewModel che verranno chiusi quando il ViewModel viene cancellato senza richiedere alcun intervento manuale in onCleared().

Ad esempio, per creare un ambito coroutine che puoi iniettare in un ViewModel, ma controllare tramite i test, puoi creare un CoroutineScope che implementa Closeable:

class CloseableCoroutineScope(
    context: CoroutineContext = SupervisorJob() + Dispatchers.Main.immediate
) : Closeable, CoroutineScope {
    override val coroutineContext: CoroutineContext = context
    override fun close() {
        coroutineContext.cancel()
   }
}

che può essere utilizzato nel costruttore ViewModel mantenendo la stessa durata di viewModelScope:

class TestScopeViewModel(
    val customScope: CloseableCoroutineScope = CloseableCoroutineScope()
) : ViewModel(customScope) {
    // You can now use customScope in the same way as viewModelScope
}

Modifiche al comportamento

Il tentativo di spostare Lifecycle.State da INITIALIZED a DESTROYED ora genera sempre un IllegalStateException, indipendentemente dal fatto che Lifecycle abbia un osservatore collegato.
Ora LifecycleRegistry eliminerà gli osservatori quando raggiunge lo stato DESTROYED.

Versione 2.5.0-rc02

15 giugno 2022

androidx.lifecycle:lifecycle-*:2.5.0-rc02 viene rilasciato. La versione 2.5.0-rc02 contiene questi commit.

Correzioni di bug

ViewModelProvider non avrà più arresti anomali quando vengono mescolate le versioni precedenti delle dipendenze del ciclo di vita compileOnly con le versioni 2.5 e successive. (I81a66, b/230454566)

Versione 2.5.0-rc01

11 maggio 2022

androidx.lifecycle:lifecycle-*:2.5.0-rc01 viene rilasciato. La versione 2.5.0-rc01 contiene questi commit.

Correzioni di bug

MediatorLiveData.addSource() ora genera un NullPointerException quando viene passata una sorgente null anziché propagare la sorgente null agli osservatori.(Ibd0fb, b/123085232)

Versione 2.5.0-beta01

20 aprile 2022

androidx.lifecycle:lifecycle-*:2.5.0-beta01 viene rilasciato. La versione 2.5.0-beta01 contiene questi commit.

Modifiche all'API

Sono stati aggiunti delegati della proprietà SavedStateHandle.saveable per utilizzare i nomi delle proprietà come chiavi per la persistenza dello stato in SavedStateHandle (I8bb86, b/225014345)

Correzioni di bug

È stato risolto un problema per cui l'annidamento di un NavHost all'interno di un altro NavHost in una scheda di navigazione inferiore non principale generava un IllegalStateException quando si utilizzavano più serie di schede Indietro. (I11bd5, b/228865698)

Versione 2.5.0-alpha06

6 aprile 2022

androidx.lifecycle:lifecycle-*:2.5.0-alpha06 viene rilasciato. La versione 2.5.0-alpha06 contiene questi commit.

Nuove funzionalità

Aggiungi un sovraccarico MutableState sperimentale a SavedStateHandle.saveable per equipararlo a rememberSaveable (I38cfe, b/224565154)

Modifiche all'API

CreationExtras ora è astratto anziché sigillato. (Ib8a7a)

Correzioni di bug

È stato corretto un errore IllegalStateException: Already attached to lifecycleOwner causato da SavedStateHandleController. (I7ea47, b/215406268)

Versione 2.5.0-alpha05

23 marzo 2022

androidx.lifecycle:lifecycle-*:2.5.0-alpha05 viene rilasciato. La versione 2.5.0-alpha05 contiene questi commit.

Nuove funzionalità

Il modulo lifecycle-viewmodel-compose ora fornisce SavedStateHandleSaver, un'API sperimentale che garantisce che i valori in un SavedStateHandle vengano integrati correttamente con lo stesso stato dell'istanza salvato utilizzato da rememberSaveable. (Ia88b7, b/195689777)

Modifiche all'API

È stato risolto un problema di compatibilità con Lifecycle 2.3 e le versioni successive di Lifecycle in Java. (I52c8a, b/219545060)

Correzioni di bug

SavedStateViewFactory ora supporta l'utilizzo di CreationExtras anche se è stato inizializzato con un SavedStateRegistryOwner. Se vengono forniti extra, gli argomenti inizializzati vengono ignorati. (I6c43b, b/224844583)

Versione 2.5.0-alpha04

9 marzo 2022

androidx.lifecycle:lifecycle-*:2.5.0-alpha04 viene rilasciato. La versione 2.5.0-alpha04 contiene questi commit.

Modifiche all'API

SavedStateHandle ora offre un'API getStateFlow() che restituisce un StateFlow di Kotlin per monitorare le variazioni di valore come alternativa all'utilizzo di LiveData. (Iad3ab, b/178037961)

Versione 2.5.0-alpha03

23 febbraio 2022

androidx.lifecycle:lifecycle-*:2.5.0-alpha03 viene rilasciato. La versione 2.5.0-alpha03 contiene questi commit.

Nuove funzionalità

È stata aggiunta un'API addCloseable() e un nuovo sovraccarico del costruttore che ti consentono di aggiungere uno o più oggetti Closeable all'oggetto ViewModel che verrà chiuso quando l'oggetto ViewModel viene cancellato senza richiedere alcun intervento manuale in onCleared(). (I55ea0)
lifecycle-viewmodel ora fornisce un InitializerViewModelFactory che ti consente di aggiungere lambda per gestire particolari classi ViewModel, utilizzando CreationExtras come origine dati principale. (If58fc, b/216687549)
lifecycle-viewmodel-compose ora offre un'API viewModel() che utilizza una factory lambda per creare un'istanza ViewModel senza richiedere la creazione di un ViewModelProvider.Factory personalizzato. (I97fbb, b/216688927)

Modifiche all'API

Ora puoi creare un ViewModel con CreationExtras tramite lifecycle-viewmodel-compose. (I08887, b/216688927)

Modifiche al comportamento

Il tentativo di spostare Lifecycle.State da INITIALIZED a DESTROYED ora restituirà sempre un IllegalStateException, indipendentemente dall'eventuale presenza di un osservatore associato a Lifecycle. (I7c390, b/177924329)
LifecycleRegistry ora eliminerà gli osservatori quando raggiunge lo stato DESTROYED. (I4f8dd, b/142925860)

Versione 2.5.0-alpha02

9 febbraio 2022

androidx.lifecycle:lifecycle-*:2.5.0-alpha02 viene rilasciato. La versione 2.5.0-alpha02 contiene questi commit.

Modifiche all'API

SavedStateHandle e SavedStateViewModelFactory sono stati convertiti in Kotlin. In questo modo è stata migliorata la nullabilità dei generici in entrambe le classi. (Ib6ce2, b/216168263, I9647a, b/177667711)
Il parametro della funzione LiveData switchMap ora può avere un output nullable. (I40396, b/132923666)
Le estensioni LiveData -ktx sono ora annotate con @CheckResult per imporre l'utilizzo del risultato quando si chiamano queste funzioni. (Ia0f05, b/207325134)

Modifiche al comportamento

SavedStateHandle ora memorizza correttamente il valore predefinito quando non esiste alcun valore per la chiave specificata. (I1c6ce, b/178510877)

Correzioni di bug

Da Lifecycle 2.4.1: è stato aggiornato lifecycle-process in modo che dipenda da Startup 1.1.1 per garantire che le correzioni che impediscono a ProcessLifecycleInitializer di generare un StartupException siano disponibili per impostazione predefinita. (Ib01df, b/216490724)
Ora è disponibile un messaggio di errore migliorato quando le classi AndroidViewModel personalizzate hanno parametri nell'ordine sbagliato e si tenta di creare un ViewModel. (I340f7, b/177667711)
Ora puoi creare un modello di visualizzazione tramite CreationExtras utilizzando AndroidViewModelFactory senza impostare un'applicazione. (I6ebef, b/217271656)

Versione 2.5.0-alpha01

26 gennaio 2022

androidx.lifecycle:lifecycle-*:2.5.0-alpha01 viene rilasciato. La versione 2.5.0-alpha01 contiene questi commit.

ViewModel CreationExtras

Con questa release, stiamo gettando le basi per ristrutturare il modo in cui viene costruito un ViewModel. Anziché un insieme rigido di sottoclassi di ViewModelProvider.Factory che aggiungono ciascuna funzionalità aggiuntive (consentendo un parametro del costruttore Application tramite AndroidViewModelFactory, consentendo un parametro del costruttore SavedStateHandle tramite SavedStateViewModelFactory e AbstractSavedStateViewModelFactory e così via), stiamo passando a un mondo di fabbriche senza stato che si basano su un nuovo concetto, CreationExtras. (Ia7343, b/188691010, b/188541057)

Con questa modifica, ViewModelProvider non esegue più chiamate dirette al metodo create(Class<T>) precedente di ViewModelProvider.Factory. ma chiama una nuova sovraccarica di create: create(Class<T>, CreationExtras). Ciò significa che qualsiasi implementazione diretta dell'istanza ViewModelProvider.Factory ora ha accesso a ciascuno di questi nuovi CreationExtras:

ViewModelProvider.NewInstanceFactory.VIEW_MODEL_KEY: questo String fornisce l'accesso alla chiave personalizzata passata a ViewModelProvider.get().
ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY fornisce l'accesso al corso Application.
SavedStateHandleSupport.SAVED_STATE_REGISTRY_OWNER_KEY fornisce l'accesso a SavedStateRegistryOwner utilizzato per costruire questo ViewModel.
SavedStateHandleSupport.VIEW_MODEL_STORE_OWNER_KEY fornisce l'accesso a ViewModelStoreOwner utilizzato per costruire questo ViewModel.
SavedStateHandleSupport.DEFAULT_ARGS_KEY fornisce l'accesso all'Bundle di argomenti da utilizzare per creare un SavedStateHandle.

Questi extra vengono forniti per impostazione predefinita quando utilizzi Attività 1.5.0-alpha01, Componente 1.5.0-alpha01 e Navigazione 2.5.0-alpha01. Se utilizzi una versione precedente di queste librerie, CreationExtras sarà vuoto: tutti i sottoclassi esistenti di CreationExtras sono stati riscritti per supportare sia il percorso di creazione precedente utilizzato dalle versioni precedenti di queste librerie sia il percorso CreationExtras che verrà utilizzato in futuro.ViewModelProvider.Factory

Questi CreationExtras ti consentono di creare un ViewModelProvider.Factory che trasmette solo le informazioni necessarie a ogni ViewModel senza fare affidamento su una gerarchia rigida di sottoclassi Factory:

class CustomFactory : ViewModelProvider.Factory {
    override fun <T : ViewModel> create(modelClass: Class<T>, extras: CreationExtras): T {
        return when (modelClass) {
            HomeViewModel::class -> {
                // Get the Application object from extras
                val application = checkNotNull(extras[ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY])
                // Pass it directly to HomeViewModel
                HomeViewModel(application)
            }
            DetailViewModel::class -> {
                // Create a SavedStateHandle for this ViewModel from extras
                val savedStateHandle = extras.createSavedStateHandle()
                DetailViewModel(savedStateHandle)
            }
            else -> throw IllegalArgumentException("Unknown class $modelClass")
        } as T
    }
}

Utilizziamo la funzione di estensione Kotlin createSavedStateHandle() su CreationExtras da SavedStateHandleSupport per creare un SavedStateHandle solo per l'unico ViewModel che ne ha bisogno. (Ia6654, b/188541057)

CreationExtras personalizzato può essere fornito sostituendo getDefaultViewModelCreationExtras() in ComponentActivity o Fragment, rendendoli così disponibili per ViewModelProvider.Factory personalizzato come forma integrata di inserimento assistito. Questi extra verranno resi disponibili automaticamente per la tua Factory personalizzata se utilizzati direttamente con ViewModelProvider o con le estensioni delle proprietà Kotlin by viewModels() e by activityViewModels(). (I79f2b, b/207012584, b/207012585, b/207012490)

Correzioni di bug

È stato risolto un problema per cui il valore predefinito fornito a un SavedStateHandle riappariva dopo l'interruzione e la nuova creazione del processo, anche se era stato specificamente rimosso dal SavedStateHandle. Di conseguenza, SavedStateHandle non unirá più i valori predefiniti e quelli ripristinati, ma utilizzerà solo i valori ripristinati come fonte attendibile. (I53a4b)

Versione 2.4

Versione 2.4.1

9 febbraio 2022

androidx.lifecycle:lifecycle-*:2.4.1 viene rilasciato. La versione 2.4.1 contiene questi commit.

Correzioni di bug

Backportato da Lifecycle 2.5.0-alpha01: è stato risolto un problema per cui il valore predefinito fornito a un SavedStateHandle riappariva dopo l'interruzione e la nuova creazione del processo, anche se era stato specificamente rimosso dal SavedStateHandle. Di conseguenza, SavedStateHandle non unirá più i valori predefiniti e quelli ripristinati, ma utilizzerà solo i valori ripristinati come fonte attendibile. (I53a4b)
lifecycle-process ora dipende da Androidx Startup 1.1.1, che ha risolto una regressione in cui l'utilizzo di ProcessLifecycleInitializer causava un StartupException. (b/216490724)

Versione 2.4.0

27 ottobre 2021

androidx.lifecycle:lifecycle-*:2.4.0 viene rilasciato. La versione 2.4.0 contiene questi commit.

Modifiche importanti dalla versione 2.3.0

@OnLifecycleEvent è stato deprecato. Dovresti utilizzare LifecycleEventObserver o DefaultLifecycleObserver.
La raccolta androidx.lifecycle:lifecycle-viewmodel-compose è stata aggiunta. Fornisce viewModel() composable e LocalViewModelStoreOwner.
- Modifica che comporta la rottura del codice sorgente: ViewModelProvider è stato riscritto in Kotlin. Il metodo ViewModelProvider.Factory.create non consente più generici nullable.
A androidx.lifecycle:lifecycle-runtime-ktx sono state aggiunte nuove API di coroutine:
Lifecycle.repeatOnLifecycle, API che esegue un blocco di codice in una coroutine quando il ciclo di vita è almeno in un determinato stato. Il blocco verrà annullato e riavviato man mano che il ciclo di vita passa e esce dallo stato target.
Flow.flowWithLifecycle, API che emette valori dal flusso a monte quando il ciclo di vita è almeno in un determinato stato.
DefaultLifecycleObserver è stato spostato da lifecycle.lifecycle-common-java8 a lifecycle.lifecycle-common. lifecycle.lifecycle-common-java8non fornisce più funzionalità aggiuntive rispetto a lifecycle.lifecycle-common, pertanto la dipendenza da lifecycle.lifecycle-common-java8 può essere sostituita da lifecycle.lifecycle-common.
Le API non coroutine di lifecycle-viewmodel-ktx sono state spostate nel modulo lifecycle-viewmodel.

lifecycle-process ora utilizza androidx.startup per inizializzare ProcessLifecycleOwner.

In precedenza, questa operazione veniva eseguita da androidx.lifecycle.ProcessLifecycleOwnerInitializer.

Se in passato hai utilizzato tools:node="remove", il valore ContentProvider utilizzato per inizializzare il ciclo di vita del processo, devi eseguire la procedura descritta di seguito.

 <provider
    android:name="androidx.startup.InitializationProvider"
    android:authorities=\"${applicationId}.androidx-startup"
    android:exported="false"
    tools:node=\"merge">
    <!-- If you are using androidx.startup to initialize other components -->
    <meta-data
        android:name="androidx.lifecycle.ProcessLifecycleInitializer"
        android:value="androidx.startup"
        tools:node="remove" />
 </provider>

(oppure)

 <!-- If you want to disable androidx.startup completely. -->
 <provider
    android:name="androidx.startup.InitializationProvider"
    android:authorities="${applicationId}.androidx-startup"
    tools:node="remove">
 </provider>

Versione 2.4.0-rc01

29 settembre 2021

androidx.lifecycle:lifecycle-*:2.4.0-rc01 viene rilasciato senza modifiche rispetto a Lifecycle 2.4.0-beta01. La versione 2.4.0-rc01 contiene questi commit.

Versione 2.4.0-beta01

15 settembre 2021

androidx.lifecycle:lifecycle-*:2.4.0-beta01 viene rilasciato. La versione 2.4.0-beta01 contiene questi commit.

Modifiche all'API

@OnLifecycleEvent è stato deprecato. Dovresti utilizzare LifecycleEventObserver o DefaultLifecycleObserver. (I5a8fa)
DefaultLifecycleObserver è stato spostato da androidx.lifecycle.lifecycle-common-java8 a androidx.lifecycle.lifecycle-common. androidx.lifecycle.lifecycle-common-java8 non fornisce più funzionalità aggiuntive rispetto a androidx.lifecycle.lifecycle-common, pertanto la dipendenza da androidx.lifecycle.lifecycle-common-java8 può essere sostituita da androidx.lifecycle.lifecycle-common. (I021aa)
Le API non coroutine di lifecycle-viewmodel-ktx sono state spostate nel modulo lifecycle-viewmodel. (I6d5b2)

Contributo esterno

Grazie a dmitrilc per aver corretto un tipo nella documentazione di ViewModel. (#221)

Versione 2.4.0-alpha03

4 agosto 2021

androidx.lifecycle:lifecycle-*:2.4.0-alpha03 viene rilasciato. La versione 2.4.0-alpha03 contiene questi commit.

Modifiche all'API

Modifica che comporta la rottura del codice sorgente: ViewModelProvider è stato riscritto in Kotlin. Il metodo ViewModelProvider.Factory.create non consente più generici nullable. (I9b9f6)

Modifiche al comportamento

Ora Lifecycle.repeatOnLifecycle: block viene sempre invocato in modo seriale quando si ripete l'esecuzione. (Ibab33)

Contributo esterno

Grazie a chao2zhang per aver corretto gli snippet di codice nella documentazione di repeatOnLifecycle. #205.

Versione 2.4.0-alpha02

16 giugno 2021

androidx.lifecycle:lifecycle-*:2.4.0-alpha02 viene rilasciato. La versione 2.4.0-alpha02 contiene questi commit.

Nuove funzionalità

È stato aggiunto un nuovo controllo lint RepeatOnLifecycleWrongUsage a lifecycle-runtime-ktx che rileva quando repeateOnLifecycle viene utilizzato in modo errato in onStart() o onResume(). (706078, b/187887400)

Modifiche all'API

L'API LifecycleOwner.addRepeatingJob viene rimossa in favore di Lifecycle.repeatOnLifecycle, che rispetta la concorrenza strutturata ed è più facile da comprendere. (I4a3a8)
Rendi pubblico ProcessLifecycleInitializer in modo che altri androidx.startup.Initializer possano utilizzarlo come dipendenze. (I94c31)

Correzioni di bug

È stato risolto un problema con il controllo lint NullSafeMutableLiveData quando il campo ha modificatori. (#147, b/183696616)
È stato risolto un altro problema con il controllo lint NullSafeMutableLiveData quando vengono utilizzati i generici. (#161, b/184830263)

Contributo esterno

Grazie a maxsav per aver migliorato il controllo lint di NullSafeMutableLiveData. (#147, b/183696616)
Grazie a kozaxinan per aver migliorato il controllo lint NullSafeMutableLiveData. (#161, b/184830263)

Versione 2.4.0-alpha01

24 marzo 2021

androidx.lifecycle:lifecycle-*:2.4.0-alpha01 viene rilasciato. La versione 2.4.0-alpha01 contiene questi commit.

Modifiche al comportamento

lifecycle-process ora utilizza androidx.startup per inizializzare ProcessLifecycleOwner.

In precedenza, questa operazione veniva eseguita da androidx.lifecycle.ProcessLifecycleOwnerInitializer.

Se in passato hai utilizzato tools:node="remove", il valore ContentProvider utilizzato per inizializzare il ciclo di vita del processo, devi eseguire la procedura descritta di seguito.

 <provider
    android:name="androidx.startup.InitializationProvider"
    android:authorities=\"${applicationId}.androidx-startup"
    android:exported="false"
    tools:node=\"merge">
    <!-- If you are using androidx.startup to initialize other components -->
    <meta-data
        android:name="androidx.lifecycle.ProcessLifecycleInitializer"
        android:value="androidx.startup"
        tools:node="remove" />
 </provider>

(oppure)

 <!-- If you want to disable androidx.startup completely. -->
 <provider
    android:name="androidx.startup.InitializationProvider"
    android:authorities="${applicationId}.androidx-startup"
    tools:node="remove">
 </provider>

Modifiche all'API

È stata aggiunta un'API Flow.flowWithLifecycle che emette valori dal flusso a monte quando il ciclo di vita è almeno in un determinato stato utilizzando l'API Lifecycle.repeatOnLifecycle. Si tratta di un'alternativa alla nuova API LifecycleOwner.addRepeatinJob. (I0f4cd)

Correzioni di bug

Da Lifecycle 2.3.1: la regola di lint NonNullableMutableLiveData ora può distinguere correttamente tra le variabili di campo con valori null diversi. (b/169249668)

Lifecycle Viewmodel Compose versione 1.0.0

Versione 1.0.0-alpha07

16 giugno 2021

androidx.lifecycle:lifecycle-viewmodel-compose:1.0.0-alpha07 viene rilasciato. La versione 1.0.0-alpha07 contiene questi commit.

Modifiche alle API che comportano interruzione del servizio

viewModel() ora accetta un ViewModelStoreOwner facoltativo, semplificando il lavoro con proprietari diversi da LocalViewModelStoreOwner. Ad esempio, ora puoi utilizzare viewModel(navBackStackEntry) per recuperare un ViewModel associato a un determinato grafo di navigazione. (I2628d, b/188693123)

Versione 1.0.0-alpha06

2 giugno 2021

androidx.lifecycle:lifecycle-viewmodel-compose:1.0.0-alpha06 viene rilasciato. La versione 1.0.0-alpha06 contiene questi commit.

Aggiornato per essere compatibile con la versione 1.0.0-beta08 di Compose.

Versione 1.0.0-alpha05

18 maggio 2021

androidx.lifecycle:lifecycle-viewmodel-compose:1.0.0-alpha05 viene rilasciato. La versione 1.0.0-alpha05 contiene questi commit.

Nuove funzionalità

Aggiornato per essere compatibile con la versione 1.0.0-beta07 di Compose.

Correzioni di bug

I file AndroidManifest di ui-test-manifest e ui-tooling-data ora sono compatibili con Android 12 (I6f9de, b/184718994)

Versione 1.0.0-alpha04

7 aprile 2021

androidx.lifecycle:lifecycle-viewmodel-compose:1.0.0-alpha04 viene rilasciato. La versione 1.0.0-alpha04 contiene questi commit.

Modifiche alle dipendenze

Questa versione consente a androidx.hilt:hilt-navigation-compose e androidx.navigation:navigation-compose di sincronizzare le dipendenze su androidx.compose.compiler:compiler:1.0.0-beta04 e androidx.compose.runtime:runtime:1.0.0-beta04. Per 1.0.0, è necessario che il compilatore e il runtime corrispondano.

Versione 1.0.0-alpha03

10 marzo 2021

androidx.lifecycle:lifecycle-viewmodel-compose:1.0.0-alpha03 viene rilasciato. La versione 1.0.0-alpha03 contiene questi commit.

Modifiche all'API

LocalViewModelStoreOwner.current ora restituisce un valore ViewModelStoreOwner facoltativo per determinare meglio se un valore ViewModelStoreOwner è disponibile nella composizione corrente. Le API che richiedono un ViewModelStoreOwner, come viewModel() e NavHost, generano comunque un'eccezione se non è impostato un ViewModelStoreOwner. (Idf39a)

Lifecycle-Viewmodel-Compose versione 1.0.0-alpha02

24 febbraio 2021

androidx.lifecycle:lifecycle-viewmodel-compose:1.0.0-alpha02 viene rilasciato. La versione 1.0.0-alpha02 contiene questi commit.

Modifiche all'API

LocalViewModelStoreOwner ora dispone di funzioni provides che possono essere utilizzate con CompositionLocalProvider, sostituendo l'API asProvidableCompositionLocal(). (I45d24)

Lifecycle-Viewmodel-Compose versione 1.0.0-alpha01

10 febbraio 2021

androidx.lifecycle:lifecycle-viewmodel-compose:1.0.0-alpha01 viene rilasciato. La versione 1.0.0-alpha01 contiene questi commit.

Nuove funzionalità

Il composable viewModel() e LocalViewModelStoreOwner sono stati spostati da androidx.compose.ui.viewinterop a questo elemento nel pacchetto androidx.lifecycle.viewmodel.compose. (I7a374)

Versione 2.3.1

Versione del ciclo di vita 2.3.1

24 marzo 2021

androidx.lifecycle:lifecycle-*:2.3.1 viene rilasciato. La versione 2.3.1 contiene questi commit.

Correzioni di bug

Ora la regola di lint NonNullableMutableLiveData può distinguere correttamente tra le variabili di campo con valori null diversi. (b/169249668)

Versione 2.3.0

10 febbraio 2021

androidx.lifecycle:lifecycle-*:2.3.0 viene rilasciato. La versione 2.3.0 contiene questi commit.

Modifiche principali dalla versione 2.2.0

Supporto di SavedStateHandle per le classi non parcellabili: SavedStateHandle ora supporta la serializzazione lazy consentendo di chiamare setSavedStateProvider() per una determinata chiave, fornendo un SavedStateProvider che riceverà un callback a saveState() quando a SavedStateHandle viene chiesto di salvare il proprio stato. Consulta Salvare classi non frazionabili.
Applicazione del comportamento del ciclo di vita:
- LifecycleRegistry ora applica DESTROYED come stato terminale.
- LifecycleRegistry ora verifica che i suoi metodi vengano chiamati nel thread principale. È sempre stato un requisito per i cicli di vita di attività, frammenti e così via. L'aggiunta di osservatori da thread non principali ha comportato arresti anomali difficili da rilevare in fase di esecuzione. Per gli oggetti LifecycleRegistry di proprietà dei tuoi componenti, puoi disattivare esplicitamente i controlli utilizzando LifecycleRegistry.createUnsafe(...), ma devi assicurarti che sia in atto una sincronizzazione corretta quando si accede a questo LifecycleRegistry da thread diversi.
Funzionalità di assistenza per stati ed eventi del ciclo di vita: sono stati aggiunti metodi di assistenza statici di downFrom(State), downTo(State), upFrom(State), upTo(State) a Lifecycle.Event per generare Event a partire da State e dalla direzione di transizione. È stato aggiunto il metodo getTargetState() che fornisce il valore State a cui il ciclo di vita passerà direttamente dopo il valore Event.
withStateAtLeast: sono state aggiunte API Lifecycle.withStateAtLeast che attendono uno stato del ciclo di vita ed eseguono in modo sincrono un blocco di codice che non sospende al momento della modifica dello stato, per poi riprendere con il risultato. Queste API sono diverse dai metodi when* esistenti in quanto non consentono l'esecuzione di codice in sospensione e non utilizzano un gestore personalizzato. (aosp/1326081)
API ViewTree: una nuova API ViewTreeLifecycleOwner.get(View) e ViewTreeViewModelStoreOwner.get(View) consente di recuperare rispettivamente LifecycleOwner e ViewModelStoreOwner contenenti, a partire da un'istanza View. Per compilare correttamente questo campo, devi eseguire l'upgrade ad Activity 1.2.0 e Fragment 1.3.0 e ad AppCompat 1.3.0-alpha01 o versioni successive. Le estensioni Kotlin findViewTreeLifecycleOwner e findViewTreeViewModelStoreOwner sono disponibili rispettivamente in lifecycle-runtime-ktx e lifecycle-viewmodel-ktx.
Ritiro dell'estensione Kotlin LiveData.observe(): l'estensione Kotlin LiveData.observe() necessaria per utilizzare la sintassi lambda è ora ritirata perché non è necessaria quando si utilizza Kotlin 1.4.

Versione 2.3.0-rc01

16 dicembre 2020

androidx.lifecycle:lifecycle-*:2.3.0-rc01 viene rilasciato. La versione 2.3.0-rc01 contiene questi commit.

Correzioni di bug

Il metodo keys() di SavedStateHandle è ora coerente prima e dopo il salvataggio dello stato. Ora include le chiavi utilizzate in precedenza con setSavedStateProvider(), oltre a quelle utilizzate con set() e getLiveData(). (aosp/1517919, b/174713653)

Contributo esterno

Le API per sospendere le coroutine consapevoli del ciclo di vita ora gestiscono meglio le chiamate a yield(). Grazie Nicklas Ansman Giertz! (aosp/1430830, b/168777346)

Versione 2.3.0-beta01

1° ottobre 2020

androidx.lifecycle:lifecycle-*:2.3.0-beta01 viene rilasciato. La versione 2.3.0-beta01 contiene questi commit.

Modifiche all'API

L'estensione Kotlin LiveData.observe() necessaria per utilizzare la sintassi lambda è stata ritirata perché non è necessaria quando si utilizza Kotlin 1.4. (I40d3f)

Correzioni di bug

Esegui l'upgrade di androidx per utilizzare Kotlin 1.4 (Id6471, b/165307851, b/165300826)

Modifiche alla documentazione

I documenti del generatore liveData e di asLiveData() sono stati aggiornati per includere i dettagli sulla modifica dei valori di timeout specificati. (aosp/1122324)

Versione 2.3.0-alpha07

19 agosto 2020

androidx.lifecycle:lifecycle-*:2.3.0-alpha07 viene rilasciato. La versione 2.3.0-alpha07 contiene questi commit.

Correzioni di bug

È stato risolto un problema di arresto anomalo nel NullSafeMutableLiveData controllo Lint. (aosp/1395367)

Versione 2.3.0-alpha06

22 luglio 2020

androidx.lifecycle:lifecycle-*:2.3.0-alpha06 viene rilasciato. La versione 2.3.0-alpha06 contiene questi commit.

Nuove funzionalità

Sono stati aggiunti metodi di assistenza statici di downFrom(State), downTo(State), upFrom(State), upTo(State) a Lifecycle.Event per generare Event a partire da State e dalla direzione di transizione. È stato aggiunto il metodo getTargetState() che fornisce il valore State a cui il ciclo di vita passerà direttamente dopo il valore Event. (I00887)
Sono state aggiunte API Lifecycle.withStateAtLeast che attendono uno stato del ciclo di vita ed eseguono in modo sincrono un blocco di codice non in sospensione al momento della modifica dello stato, per poi riprendere con il risultato. Queste API sono diverse dai metodi when* esistenti in quanto non consentono l'esecuzione di codice in sospensione e non utilizzano un gestore personalizzato. (aosp/1326081)

Modifiche al comportamento

LifecycleRegistry ora applica DESTROYED come stato terminale. (I00887)
LifecycleRegistry ora verifica che i suoi metodi vengano chiamati nel thread principale. È sempre stato un requisito per i cicli di vita di attività, frammenti e così via. L'aggiunta di osservatori da thread non principali ha comportato arresti anomali difficili da rilevare in fase di esecuzione. Per gli oggetti LifecycleRegistry di proprietà dei tuoi componenti, puoi disattivare esplicitamente i controlli utilizzando LifecycleRegistry.createUnsafe(...), ma devi assicurarti che sia in atto una sincronizzazione corretta quando si accede a questo LifecycleRegistry da thread diversi (Ie7280, b/137392809)

Correzioni di bug

È stato risolto un arresto anomalo in NullSafeMutableLiveData. (b/159987480)
È stato corretto un ObsoleteLintCustomCheck per i controlli Lint in bundle con lifecycle-livedata-core-ktx (e in particolare NullSafeMutableLiveData). (b/158699265)

Versione 2.3.0-alpha05

24 giugno 2020

androidx.lifecycle:lifecycle-*:2.3.0-alpha05 viene rilasciato. La versione 2.3.0-alpha05 contiene questi commit.

Correzioni di bug

LiveData ora gestisce meglio i casi ricorsivi, evitando chiamate duplicate a onActive() o onInactive(). (b/157840298)
È stato risolto un problema per cui i controlli Lint non venivano eseguiti quando si utilizzava Android Studio 4.1 Canary 6 o versioni successive. (aosp/1331903)

Versione 2.3.0-alpha04

10 giugno 2020

androidx.lifecycle:lifecycle-*:2.3.0-alpha04 viene rilasciato. La versione 2.3.0-alpha04 contiene questi commit.

Correzioni di bug

Risolto un arresto anomalo nel controllo Lint di NonNullableMutableLiveData. (b/157294666)
Il controllo Lint NonNullableMutableLiveData ora copre un numero molto maggiore di casi in cui è stato impostato un valore null su un MutableLiveData con un parametro di tipo non nullo. (b/156002218)

Versione 2.3.0-alpha03

20 maggio 2020

androidx.lifecycle:lifecycle-*:2.3.0-alpha03 sono state rilasciate. La versione 2.3.0-alpha03 contiene questi commit.

Nuove funzionalità

SavedStateHandle ora supporta la serializzazione lazy consentendoti di chiamare setSavedStateProvider() per una determinata chiave, fornendo un SavedStateProvider che riceverà un callback a saveState() quando a SavedStateHandle viene chiesto di salvare il suo stato. (b/155106862)
Una nuova API ViewTreeViewModelStoreOwner.get(View) consente di recuperare il ViewModelStoreOwner contenente in base a un'istanza View. Per compilare correttamente questo campo, devi eseguire l'upgrade ad Activity 1.2.0-alpha05, Fragment 1.3.0-alpha05 e AppCompat 1.3.0-alpha01. A lifecycle-viewmodel-ktx è stata aggiunta un'estensione Kotlin findViewModelStoreOwner(). (aosp/1295522)

Correzioni di bug

È stato risolto un problema che impediva la pubblicazione dei controlli MutableLiveData Lint rilasciati in Lifecycle 2.3.0-alpha01 insieme all'elemento lifecycle-livedata-core-ktx. (b/155323109)

Versione 2.3.0-alpha02

29 aprile 2020

androidx.lifecycle:lifecycle-*:2.3.0-alpha02 viene rilasciato. La versione 2.3.0-alpha02 contiene questi commit.

Modifiche all'API

SavedStateViewModelFactory ora consente di passare un Application nullo al relativo costruttore per supportare meglio i casi in cui non è immediatamente disponibile e non è necessario il supporto di AndroidViewModel. (aosp/1285740)

Correzioni di bug

Miglioramento del rendimento dell'avvio a freddo evitando l'errore di verifica della classe sui dispositivi con API 28 e versioni precedenti. (aosp/1282118)

Versione 2.3.0-alpha01

4 marzo 2020

androidx.lifecycle:lifecycle-*:2.3.0-alpha01 viene rilasciato. La versione 2.3.0-alpha01 contiene questi commit.

Nuove funzionalità

Una nuova API ViewTreeLifecycleOwner.get(View) consente di recuperare il LifecycleOwner contenente in base a un'istanza View. Per compilare correttamente questo campo, devi eseguire l'upgrade ad Attività 1.2.0-alpha01 e Frammento 1.3.0-alpha01. In lifecycle-runtime-ktx è disponibile un'estensione Kotlin per findViewTreeLifecycleOwner. (aosp/1182361, aosp/1182956)
È stato aggiunto un nuovo controllo Lint che ti avvisa quando imposti un valore null su un MutableLiveData che è stato definito in Kotlin come non nullo. Questa opzione è disponibile quando utilizzi gli elementi livedata-core-ktx o livedata-ktx. (aosp/1154723, aosp/1159092)
È disponibile un nuovo elemento lifecycle-runtime-testing che fornisce un TestLifecycleOwner che implementa LifecycleOwner e fornisce un Lifecycle mutabile sicuro per i thread. (aosp/1242438)

Correzioni di bug

L'elemento lifecycle-runtime ora ha un nome del pacchetto univoco. (aosp/1187196)

Versione 2.2.0

ViewModel-Savedstate versione 2.2.0

5 febbraio 2020

androidx.lifecycle:lifecycle-viewmodel-savedstate:2.2.0 viene rilasciato. La versione 2.2.0 contiene questi commit.

SavedState di Lifecycle ViewModel ora condivide la stessa versione degli altri elementi Lifecycle. Il comportamento di 2.2.0 è identico a quello di 1.0.0.

Versione 2.2.0

22 gennaio 2020

androidx.lifecycle:lifecycle-*:2.2.0 viene rilasciato. La versione 2.2.0 contiene questi commit.

Modifiche importanti dalla versione 2.1.0

Integrazione delle coroutine di Lifecycle: il nuovo artefatto lifecycle-runtime-ktx aggiunge l'integrazione tra Lifecycle e le coroutine Kotlin. lifecycle-livedata-ktx è stato inoltre ampliato per sfruttare le coroutine. Per maggiori dettagli, consulta Utilizzare le coroutine Kotlin con Architecture Components.
Ritiro di ViewModelProviders.of(): ViewModelProviders.of() è stato ritirato. Puoi passare un Fragment o un FragmentActivity al nuovo costruttore ViewModelProvider(ViewModelStoreOwner) per ottenere la stessa funzionalità quando utilizzi il componente Fragment 1.2.0.
Ritiro dell'elemento lifecycle-extensions: con il ritiro di ViewModelProviders.of() sopra indicato, questa release segna il ritiro dell'ultima API in lifecycle-extensions e questo elemento deve ora essere considerato ritirato nella sua interezza. Ti consigliamo vivamente di utilizzare lifecycle-service se utilizzi LifecycleService e lifecycle-process se utilizzi ProcessLifecycleOwner, a seconda degli elementi specifici del ciclo di vita di cui hai bisogno, anziché lifecycle-extensions, in quanto non verrà rilasciata una versione 2.3.0 di lifecycle-extensions in futuro.
Gradle Incremental Annotation Processor: il processore di annotazioni di Lifecycle è incrementale per impostazione predefinita. Se la tua app è scritta nel linguaggio di programmazione Java 8, puoi utilizzare DefautLifecycleObserver; se invece è scritta nel linguaggio di programmazione Java 7, puoi utilizzare LifecycleEventObserver.

Versione 2.2.0-rc03

4 dicembre 2019

androidx.lifecycle:lifecycle-*:2.2.0-rc03 viene rilasciato. La versione 2.2.0-rc03 contiene questi commit.

Correzioni di bug

È stato corretto un errore che si verificava quando un ViewModel simulato veniva memorizzato in ViewModelStore e successivamente sottoposto a query con la fabbrica predefinita.
Correggi un utilizzo di Dispatchers.Main.immediate in launchWhenCreated e metodi simili da chiamare in modo sincrono durante l'evento del ciclo di vita corrispondente. (aosp/1156203)

Contributi esterni

Grazie ad Anders Järleberg per aver contribuito alla correzione. (aosp/1156203)
Grazie a Vsevolod Tolstopyatov di Jetbrains per aver esaminato un'implementazione dell'esecuzione in linea.

Modifiche alle dipendenze

Le Estensioni del ciclo di vita ora dipendono dal frammento 1.2.0-rc03.

Versione 2.2.0-rc02

7 novembre 2019

androidx.lifecycle:lifecycle-*:2.2.0-rc02 viene rilasciato. La versione 2.2.0-rc02 contiene questi commit.

Correzioni di bug

È stato corretto un bug nella configurazione di ProGuard della libreria che interessava i dispositivi con API 28 e versioni successive se l'API target è inferiore a 29. (b/142778206)

Versione 2.2.0-rc01

23 ottobre 2019

androidx.lifecycle:lifecycle-*:2.2.0-rc01 viene rilasciato. La versione 2.2.0-rc01 contiene questi commit.

Correzioni di bug

È stato risolto un problema per cui launchWhenCreated e i metodi correlati venivano eseguiti un frame dopo il metodo del ciclo di vita associato a causa dell'utilizzo di Dispatchers.Main anziché Dispatchers.Main.immediate. (aosp/1145596)

Contributi esterni

Grazie a Nicklas Ansman per aver contribuito alla correzione. (aosp/1145596)

Versione 2.2.0-beta01

9 ottobre 2019

androidx.lifecycle:lifecycle-*:2.2.0-beta01 viene rilasciato. La versione 2.2.0-beta01 contiene questi commit.

Correzioni di bug

È stata corretta una regressione introdotta in Lifecycle 2.2.0-alpha05 nell'ordinamento di ProcessLifecycleOwner e del passaggio di LifecycleOwner dell'attività a Avviata e Ripresa sui dispositivi Android 10. (aosp/1128132)
È stata risolta una regressione introdotta nel ciclo di vita 2.2.0-alpha05 che causava un NullPointerException quando si utilizzava la versione 2.0.0 o 2.1.0 di lifecycle-process. (b/141536990)

Versione 2.2.0-alpha05

18 settembre 2019

androidx.lifecycle:lifecycle-*:2.2.0-alpha05 viene rilasciato. La versione 2.2.0-alpha05 contiene questi commit.

Correzioni di bug

È stata corretta una condizione di gara nel generatore di livedata della coroutine. b/140249349

Versione 2.2.0-alpha04

5 settembre 2019

androidx.lifecycle:lifecycle-*:2.2.0-alpha04 viene rilasciato. I commit inclusi in questa versione sono disponibili qui.

Nuove funzionalità

lifecycleScope, whenCreated, whenStarted, whenResumed, viewModelScope e l'implementazione di base di liveData ora utilizzano Dispatchers.Main.immediate anziché Dispatchers.Main. (b/139740492)

Contributi esterni

Grazie a Nicklas Ansman per aver contribuito al trasferimento a Dispatchers.Main.immediate. (aosp/1106073)

Versione 2.2.0-alpha03

7 agosto 2019

androidx.lifecycle:lifecycle-*:2.2.0-alpha03 viene rilasciato. I commit inclusi in questa versione sono disponibili qui.

Nuove funzionalità

Le implementazioni di ViewModelStoreOwner ora possono facoltativamente implementare HasDefaultViewModelProviderFactory per fornire un ViewModelProvider.Factory predefinito. Questo è stato fatto per Attività 1.1.0-alpha02, Frammento 1.2.0-alpha02 e Navigazione 2.2.0-alpha01. (aosp/1092370, b/135716331)

Modifiche all'API

ViewModelProviders.of() è stato deprecato. Puoi passare un Fragment o un FragmentActivity al nuovo costruttore ViewModelProvider(ViewModelStoreOwner) per ottenere la stessa funzionalità. (aosp/1009889)

Versione 2.2.0-alpha02

2 luglio 2019

androidx.lifecycle:*:2.2.0-alpha02 viene rilasciato. I commit inclusi in questa versione sono disponibili qui.

Modifiche all'API

LiveDataScope.initialValue è stato sostituito con LiveDataScope.latestValue, che monitora il valore emesso corrente del blocco liveData.
È stata aggiunta una nuova sovraccarica al generatore liveData che riceve il parametro timeout come tipo Duration

Versione 2.2.0-alpha01

7 maggio 2019

androidx.lifecycle:*:2.2.0-alpha01 viene rilasciato. I commit inclusi in questa versione sono disponibili qui.

Nuove funzionalità

Questa release aggiunge nuove funzionalità che supportano le coroutine Kotlin per Lifecycle e LiveData. Puoi trovare una documentazione dettagliata qui.

ViewModel-SavedState versione 1.0.0

Versione 1.0.0

22 gennaio 2020

androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0 viene rilasciato. La versione 1.0.0 contiene questi commit.

Funzionalità importanti nella versione 1.0.0

È stata aggiunta la nuova classe SavedStateHandle. Consente ai tuoi corsi ViewModel di accedere allo stato salvato e di contribuire al suo aggiornamento. Questo oggetto può essere ricevuto nel costruttore della classe ViewModel e le fabbriche fornite per impostazione predefinita da Fragments e AppCompatActivity inietteranno SavedStateHandle automaticamente.
È stata aggiunta AbstractSavedStateViewModelFactory. Ti consente di creare fabbriche personalizzate per il tuo ViewModel e di fornire loro l'accesso a SavedStateHandle.

ViewModel-Savedstate versione 1.0.0-rc03

4 dicembre 2019

androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-rc03 viene rilasciato. La versione 1.0.0-rc03 contiene questi commit.

Modifiche alle dipendenze

Lo stato Saved di Lifecycle ViewModel ora dipende da Lifecycle 2.2.0-rc03.

Viewmodel-Savedstate versione 1.0.0-rc02

7 novembre 2019

androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-rc02 viene rilasciato. La versione 1.0.0-rc02 contiene questi commit.

Modifiche alle dipendenze

Ora dipende dal ciclo di vita 2.2.0-rc02.

ViewModel-SavedState versione 1.0.0-rc01

23 ottobre 2019

androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-rc01 viene rilasciato senza modifiche rispetto a 1.0.0-beta01. La versione 1.0.0-rc01 contiene questi commit.

ViewModel-Savedstate versione 1.0.0-beta01

9 ottobre 2019

androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-beta01 viene rilasciato. La versione 1.0.0-beta01 contiene questi commit.

Correzioni di bug

È stato risolto un problema per cui l'accesso a un ViewModel SavedState per la prima volta in Activity.onActivityResult() generava un IllegalStateException. (b/139093676)
È stato corretto un IllegalStateException quando si utilizza AbstractSavedStateViewModelFactory. (b/141225984)

ViewModel-SavedState versione 1.0.0-alpha05

18 settembre 2019

androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-alpha05 viene rilasciato. La versione 1.0.0-alpha05 contiene questi commit.

Modifiche all'API

SavedStateViewModelFactory non estende più AbstractSavedStateViewModelFactory e SavedStateHandle viene creato solo per i ViewModel che lo richiedono (aosp/1113593)

ViewModel-SavedState versione 1.0.0-alpha03

7 agosto 2019

androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-alpha03 viene rilasciato. I commit inclusi in questa versione sono disponibili qui.

Modifiche che provocano un errore

lifecycle-viewmodel-savedstate non dipende più da fragment e i relativi costruttori SavedStateViewModelFactory(Fragment) e SavedStateViewModelFactory(FragmentActivity) sono stati rimossi. Al suo posto, SavedStateViewModelFactory è ora la fabbrica predefinita per Attività 1.1.0-alpha02, Componente 1.2.0-alpha02 e Navigazione 2.2.0-alpha01. (b/135716331)

ViewModel-SavedState versione 1.0.0-alpha02

2 luglio 2019

androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-alpha02 viene rilasciato. I commit inclusi in questa versione sono disponibili qui.

Nuove funzionalità

È stata aggiunta un'overload di SavedStateHandle.getLiveData() che accetta un valore predefinito.

Modifiche all'API

Il nuovo nome di SavedStateVMFactory è SavedStateViewModelFactory.
Il nuovo nome di AbstractSavedStateVMFactory è AbstractSavedStateViewModelFactory.

ViewModel-Savedstate versione 1.0.0-alpha01

13 marzo 2019

androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-alpha01 viene rilasciato. Il log dei commit completo per questa release iniziale è disponibile qui.

Nuove funzionalità

Ora ViewModels può contribuire a savedstate. A tale scopo, utilizza la factory SavedStateVMFactory del ViewModel appena introdotta e il ViewModel deve avere un costruttore che riceva l'oggetto SavedStateHandle come parametro.

Versione 2.1.0

Modifiche importanti dalla versione 2.0.0

È stato aggiunto LifecycleEventObserver per i casi in cui è necessario uno stream di eventi del ciclo di vita. Si tratta di un'API pubblica anziché di una classe GenericLifecycleObserver nascosta.
Sono state aggiunte estensioni KTX per i metodi LiveData.observe e Transformations.*.
È stato aggiunto Transformations.distinctUntilChanged, che crea un nuovo oggetto LiveData che non emette un valore finché il valore LiveData di origine non viene modificato.
È stato aggiunto il supporto delle coroutine nei ViewModel aggiungendo la proprietà di estensione ViewModel.viewModelScope.

Versione 2.1.0

5 settembre 2019

androidx.lifecycle:lifecycle-*:2.1.0 viene rilasciato. I commit inclusi in questa versione sono disponibili qui.

Versione 2.1.0-rc01

2 luglio 2019

androidx.lifecycle:*:2.1.0-rc01 viene rilasciato senza modifiche rispetto a androidx.lifecycle:*:2.1.0-beta01. I commit inclusi in questa versione sono disponibili qui.

Versione 2.1.0-beta01

7 maggio 2019

androidx.lifecycle:*:2.1.0-beta01 viene rilasciato. I commit inclusi in questa versione sono disponibili qui.

Nuove funzionalità

I cicli di vita vengono passati alla versione beta: le API introdotte nelle versioni alpha precedenti, come le funzioni di estensione liveData per trasformazioni e osservazioni, l'inizializzazione ViewModel con delega delle proprietà e altre, sono stabilizzate e non cambieranno.

Versione 2.1.0-alpha04

3 aprile 2019

androidx.lifecycle:*:2.1.0-alpha04 viene rilasciato. I commit inclusi in questa versione sono disponibili qui.

Modifiche all'API

Modifica che comporta un errore: l'API di base alla base di by viewModels() e by activityViewModels() è stata modificata per supportare direttamente un ViewModelStore anziché solo un ViewModelStoreOwner. (aosp/932932)

Versione 2.1.0-alpha03

13 marzo 2019

androidx.lifecycle:*:2.1.0-alpha03 viene rilasciato. L'elenco completo dei commit inclusi in questa versione è disponibile qui.

Modifiche all'API

Il campo ViewModelProvider.KeyedFactory è stato rimosso. La seconda interfaccia oltre a ViewModelProvider.Factory non si è composta bene con le nuove funzionalità come la delega delle proprietà in Kotlin by viewmodels {}. (aosp/914133)

Versione 2.1.0-alpha02

30 gennaio 2019

androidx.lifecycle 2.1.0-alpha02 viene rilasciato.

Modifiche all'API

LifecycleRegistry ora contiene un metodo setCurrentState() che sostituisce il metodo setState() ora deprecato. (aosp/880715)

Correzioni di bug

È stato risolto un problema per cui le istanze di ViewModel simulati si arrestavano in modo anomalo quando l'elemento ViewModelStore contenente veniva cancellato. b/122273087

Versione 2.1.0-alpha01

17 dicembre 2018

androidx.lifecycle 2.1.0-alpha01 viene rilasciato.

Nuove funzionalità

È stato aggiunto LifecycleEventObserver per i casi in cui è necessario uno stream di eventi del ciclo di vita. Si tratta di un'API pubblica anziché di una classe GenericLifecycleObserver nascosta.
Sono state aggiunte estensioni KTX per i metodi LiveData.observe e Transformations.*.
È stato aggiunto il metodo Transformations.distinctUntilChanged. Crea un nuovo oggetto LiveData che non emette un valore finché il valore LiveData di origine non è stato modificato.
Supporto delle coroutine nei ViewModel: è stata aggiunta la proprietà di estensione ViewModel.viewModelScope.
È stato aggiunto ViewModelProvider.KeyedFactory, un'azienda per i ViewModel che riceve key e Class nel metodo create.

Versione 2.0.0

21 settembre 2018

Il ciclo di vita 2.0.0 viene rilasciato con una correzione di bug da 2.0.0-rc01 in ViewModel.

Correzioni di bug

È stata corretta una regola ProGuard di ViewModel che rimuoveva in modo errato i costruttori b/112230489

Versione 2.0.0-beta01

2 luglio 2018

Correzioni di bug

È stata corretta la regola ProGuard di LifecycleObserver per mantenere solo le implementazioni, non le interfacce secondarie b/71389427
Sono state corrette le regole ProGuard di ViewModel per consentire l'oscuramento e il rimpicciolimento

Versioni precedenti ad AndroidX

Per le versioni precedenti ad AndroidX di Lifecycle che seguono, includi queste dipendenze:

dependencies {
    def lifecycle_version = "1.1.1"

    // ViewModel and LiveData
    implementation "android.arch.lifecycle:extensions:$lifecycle_version"
    // alternatively - just ViewModel
    implementation "android.arch.lifecycle:viewmodel:$lifecycle_version" // For Kotlin use viewmodel-ktx
    // alternatively - just LiveData
    implementation "android.arch.lifecycle:livedata:$lifecycle_version"
    // alternatively - Lifecycles only (no ViewModel or LiveData).
    //     Support library depends on this lightweight import
    implementation "android.arch.lifecycle:runtime:$lifecycle_version"

    annotationProcessor "android.arch.lifecycle:compiler:$lifecycle_version" // For Kotlin use kapt instead of annotationProcessor
    // alternately - if using Java8, use the following instead of compiler
    implementation "android.arch.lifecycle:common-java8:$lifecycle_version"

    // optional - ReactiveStreams support for LiveData
    implementation "android.arch.lifecycle:reactivestreams:$lifecycle_version"

    // optional - Test helpers for LiveData
    testImplementation "android.arch.core:core-testing:$lifecycle_version"
}

Versione 1.1.1

21 marzo 2018

Solo una piccola modifica: android.arch.core.util.Function viene spostato da arch:runtime a arch:common. Ciò consente di utilizzarlo senza la dipendenza di runtime, ad esempio in paging:common di seguito.

lifecycle:common è una dipendenza di lifecycle:runtime, pertanto questa modifica non influisce direttamente su lifecycle:runtime, ma solo sui moduli che dipendono direttamente da lifecycle:runtime, come Paging.lifecycle:common

Versione 1.1.0

22 gennaio 2018

Modifiche alla confezione

Sono ora disponibili nuove dipendenze molto più piccole:

android.arch.lifecycle:livedata:1.1.0
android.arch.lifecycle:viewmodel:1.1.0

Modifiche all'API

I valori LifecycleActivity e LifecycleFragment non più supportati sono stati rimossi. Utilizza FragmentActivity, AppCompatActivity o supporta Fragment.
Le annotazioni @NonNull sono state aggiunte a ViewModelProviders e ViewModelStores
Il costruttore ViewModelProviders è stato ritirato. Utilizza direttamente i relativi metodi statici
ViewModelProviders.DefaultFactory è stato deprecato. Utilizza ViewModelProvider.AndroidViewModelFactory
È stato aggiunto il metodo ViewModelProvider.AndroidViewModelFactory.getInstance(Application) statico per recuperare un Factory statico adatto alla creazione di istanze ViewModel e AndroidViewModel.