Ciclo di vita

Ciclo di vita

Guida dell'utente  Esempio di codice  Codelab

Riferimento API
androidx.lifecycle

I componenti sensibili al ciclo di vita eseguono azioni in risposta a un cambiamento dello stato del ciclo di vita di un altro componente, ad esempio attività e frammenti. Questi componenti consentono di produrre codice meglio organizzato e spesso più leggero, più facile da gestire.

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

Elemento	Release stabile	Candidato per l'uscita	Versione beta	Release alpha
ciclo di vita-*	2.8.3	-	-	-
ciclo di vita-visualizzamodello-componi	2.8.3	-	-	-

Ultimo aggiornamento di questa raccolta: 27 giugno 2024

Dichiarazione delle dipendenze

Per aggiungere una dipendenza al ciclo di vita, devi aggiungere il Repository Maven di Google al progetto. Per ulteriori informazioni, consulta il Repository Maven di Google.

Aggiungi le dipendenze per gli artefatti necessari nel file build.gradle per l'app o il modulo:

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

Kotlin

trendy

    dependencies {
        def lifecycle_version = "2.8.3"
        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.3"
        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

trendy

    dependencies {
        def lifecycle_version = "2.8.3"
        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.3"
        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 saperne di più sulle dipendenze, consulta Aggiungere dipendenze nella build.

Feedback

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

Crea un nuovo numero

Per ulteriori informazioni, consulta la documentazione di Issue Tracker.

Versione 2.8

Versione 2.8.3

27 giugno 2024

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

Correzioni di bug

• È stato risolto un problema di compatibilità con le versioni precedenti del ciclo di vita 2.8 con Compose 1.6.0 e versioni precedenti durante l'utilizzo del restringimento del codice. (aosp/3133056, b/346808608)

Versione 2.8.2

12 giugno 2024

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

Correzioni di bug

• Sono stati corretti gli errori di CompositionLocal LocalLifecycleOwner not present durante l'utilizzo di Ciclo di vita 2.8.X con Compose 1.6.X o versioni precedenti. Ora puoi utilizzare Ciclo di vita 2.8.2 con qualsiasi versione di Compose senza bisogno di soluzioni alternative. (aosp/3105647, b/336842920)
• ViewModelProvider non avrà più arresti anomali se combini le versioni precedenti delle dipendenze del ciclo di vita di compileOnly con le versioni 2.8 e versioni successive, risolvendo i problemi relativi a librerie come LeakCanary. (I80383, b/341792251)

Versione 2.8.1

29 maggio 2024

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

Correzioni di bug

• Ora lifecycle-viewmodel-compose ha una dipendenza comune solo da compose-runtime, rimuovendo la dipendenza comune da compose-ui. L'elemento Android conserva il proprio compose-ui per garantire la compatibilità. (aosp/3079334, b/339562627)
• L'integrazione ViewModel di saveable utilizzando i delegati della proprietà ora utilizza il nome della classe come parte della chiave generata automaticamente, evitando conflitti se più classi usano lo stesso SavedStateHandle. (aosp/3063463)

Versione 2.8.0

14 maggio 2024

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

Modifiche importanti dalla versione 2.7.0

• LocalLifecycleOwner è stato spostato dalla UI di Compose a lifecycle-runtime-compose in modo che le sue API helper basate su Compose possano essere utilizzate al di fuori della UI di Compose.
• L'artefatto lifecycle-runtime-compose ora contiene le API dropUnlessResumed e dropUnlessStarted che ti consentono di ignorare i clic o altri eventi che si verificano anche dopo che LifecycleOwner è sceso sotto il valore Lifecycle.State specificato. Ad esempio, puoi utilizzare questa funzionalità con Scrittura Navigazione 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 costruttore sostituibile, che ti consente di inserire il tuo supervisore e SupervisorJob() oppure di ignorare il valore predefinito utilizzando il 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 elemento key che consente di recuperarli tramite getCloseable().

• Chiamare LifecycleStartEffect e LifecycleResumeEffect senza una chiave ora è un errore, seguendo la stessa convenzione dell'API DisposableEffect che esegue il mirroring da queste API.

• LiveDataReactiveStreams.toPublisher(lifecycleOwner, liveData) ritirato a favore di LiveData.toPublisher(lifecycleOwner).

• Le estensioni Kotlin lifecycle-livedata-core-ktx sono state spostate nel modulo lifecycle-livedata-core.

• Il NullSafeMutableLiveData è stato sottoposto a refactoring per evitare molti falsi positivi.

Compatibilità multipiattaforma di Kotlin del ciclo di vita

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

Artefatti interessati:

• lifecycle-common sposta la maggior parte delle API su common e supporta jvm e iOS, oltre ad Android.
• lifecycle-runtime sposta la maggior parte delle API su common e supporta jvm e iOS, oltre ad Android.
• Il campo lifecycle-runtime-ktx è ora vuoto e tutte le API vengono spostate in lifecycle-runtime.
• lifecycle-runtime-compose sposta tutte le API su common e invia un artefatto Android, corrispondente al supporto multipiattaforma di androidx.compose.

Compatibilità multipiattaforma di ViewModel Kotlin

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

Per soddisfare questa modifica, i metodi come quelli su ViewModelProvider che hanno utilizzato un java.lang.Class<T> ora dispongono di un metodo equivalente che richiede un kotlin.reflect.KClass<T>.

La compatibilità binaria su Android è stata mantenuta, ma ci sono alcune modifiche degne di nota durante il confronto tra la piattaforma API Android e la piattaforma API comune:

• Ora la creazione di un'istanza ViewModelProvider viene eseguita tramite i metodi ViewModelProvider.create() anziché chiamare direttamente il relativo costruttore.
• ViewModelProvider.NewInstanceFactory e ViewModelProvider.AndroidViewModelFactory sono disponibili solo su Android.
  • È consigliabile estendere le fabbriche personalizzate da ViewModelProvider.Factory e utilizzare il metodo create che richiede CreationExtras o utilizzare il formato DSL Kotlin viewModelFactory.
• L'utilizzo di ViewModelProvider senza un'implementazione personalizzata su piattaforme non JVM comporterà un UnsupportedOperationException. Sulle piattaforme JVM, la compatibilità viene mantenuta utilizzando il costruttore ViewModel no-args se non viene fornito un fabbrica personalizzata.
• viewModelScope esegue il fallback di un EmptyCoroutineContext nelle piattaforme in cui Dispatchers.Main non è disponibile (ad es. Linux).

Artefatti interessati:

• lifecycle-viewmodel sposta la maggior parte delle API su common e supporta jvm e iOS, oltre ad Android.
• Il campo lifecycle-viewmodel-ktx è ora vuoto e tutte le API vengono spostate in lifecycle-viewmodel.
• lifecycle-viewmodel-compose sposta tutte le API su common e invia un artefatto Android, corrispondente al supporto multipiattaforma di androidx.compose.

Cambiamenti del comportamento

• InitializerViewModelFactory (inclusa la funzione di creazione viewModelFactory) ora genera un IllegalArgumentException se è già stato aggiunto un elemento 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

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

Correzioni di bug

• È stato risolto un problema per cui il profilo di riferimento per le classi lifecycle-common non veniva pacchettizzato correttamente. Ora sono pacchettizzati nel gestore degli account (AAR) di lifecycle-runtime. (aosp/3038274, b/322382422)
• È stato corretto un errore di modifica non intenzionale dell'ordine relativo al modo in cui le istanze AutoCloseable collegate a un ViewModel vengono cancellate: è stato ripristinato l'ordine precedente di addCloseable(String, AutoCloseable), poi addClosable(AutoCloseable) e infine onCleared(). (aosp/3041632)
• Migliora il comportamento di creazione predefinito di viewModelScope per gli ambienti nativi e JVM Desktop. (aosp/3039221)

Contributo esterno

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

Versione 2.8.0-beta01

17 aprile 2024

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

Nuove funzionalità

• L'artefatto lifecycle-runtime-compose è ora compatibile con Kotlin Multiplatform; sposta il suo codice su common e spedisce un artefatto Android, corrispondente al supporto multipiattaforma per androidx.compose. (If7a71, I4f4a0, b/331769623)

Versione 2.8.0-alpha04

3 aprile 2024

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

Nuove funzionalità

• L'artefatto lifecycle-viewmodel-compose è ora compatibile con Kotlin Multiplatform; sposta il suo codice su common e spedisce un artefatto Android, corrispondente al supporto multipiattaforma di androidx.compose. A seguito di questa modifica, il metodo componibile viewModel ora accetta un KClass oltre a un java.lang.Class. (b/330323282)

Correzioni di bug

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

Aggiornamento delle dipendenze

• L'artefatto lifecycle-viewmodel-compose ora dipende da Compose 1.6.0.
• Il ciclo di vita ora dipende dal Programma di installazione profilo 1.3.1.

Versione 2.8.0-alpha03

20 marzo 2024

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

Nuove funzionalità

• ViewModel.viewModelScope è ora un parametro costruttore sostituibile, che ti consente di inserire il tuo supervisore e SupervisorJob() oppure di ignorare il valore predefinito utilizzando il 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)
  }
  

Compatibilità multipiattaforma Kotlin

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

Per soddisfare questa modifica, i metodi come quelli su ViewModelProvider che hanno utilizzato un java.lang.Class<T> ora dispongono di un metodo equivalente che richiede un kotlin.reflect.KClass<T>.

La compatibilità binaria su Android è stata mantenuta, ma ci sono alcune modifiche degne di nota durante il confronto tra la piattaforma API Android e la piattaforma API comune:

• Ora la creazione di un'istanza ViewModelProvider viene eseguita tramite i metodi ViewModelProvider.create() anziché chiamare direttamente il relativo costruttore.
• ViewModelProvider.NewInstanceFactory e ViewModelProvider.AndroidViewModelFactory sono disponibili solo su Android.
  • È consigliabile estendere le fabbriche personalizzate da ViewModelProvider.Factory e utilizzare il metodo create che richiede CreationExtras o utilizzare il formato DSL Kotlin viewModelFactory.
• L'utilizzo di ViewModelProvider senza un'implementazione personalizzata su piattaforme non JVM comporterà un UnsupportedOperationException. Sulle piattaforme JVM, la compatibilità viene mantenuta utilizzando il costruttore ViewModel no-args se non viene fornito un fabbrica personalizzata.
• viewModelScope esegue il fallback di un EmptyCoroutineContext nelle piattaforme in cui Dispatchers.Main non è disponibile (ad es. Linux).

Cambiamenti del comportamento

• InitializerViewModelFactory (inclusa la funzione di creazione viewModelFactory) ora genera un IllegalArgumentException se è già stato aggiunto un elemento 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 risorsa precedente verrà sostituita e chiusa immediatamente. (Ibeb67)
• L'accesso all'elemento viewModelScope di un ViewModel è ora il thread sicuro. (If4766, b/322407038)

Contributo esterno

• LocalLifecycleOwner è passata dalla UI di Compose a ciclo di vita-runtime-compose in modo che le sue API helper basate su Compose possano essere utilizzate al di fuori della UI di Compose. Ringraziamo Jake Wharton per il suo contributo. (I6c41b, b/328263448)

Versione 2.8.0-alpha02

21 febbraio 2024

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

Nuove funzionalità

• Sono state aggiunte le API dropUnlessResumed e dropUnlessStarted, che ti consentono di ignorare i clic o altri eventi che si verificano anche dopo che LifecycleOwner è sceso al di sotto del valore Lifecycle.State specificato. Ad esempio, puoi usarlo con Scrittura nel navigatore 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 di Kotlin

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

Compatibilità multipiattaforma Kotlin

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

Modifiche alle API

• Chiamare LifecycleStartEffect e LifecycleResumeEffect senza una chiave ora è un errore, seguendo la stessa convenzione dell'API DisposableEffect che esegue il mirroring da queste API. (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) ritirato a favore di LiveData.toPublisher(lifecycleOwner). (Iabe29, b/262623005)

Contributo esterno

• Grazie Ivan Matkov di Jetbrains per aver contribuito a trasferire Ciclo di vita al multipiattaforma Kotlin. (aosp/2926690, I0c5ac, If445d)

Versione 2.8.0-alpha01

24 gennaio 2024

Viene rilasciato androidx.lifecycle:lifecycle-*:2.8.0-alpha01. 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

Viene rilasciato androidx.lifecycle:lifecycle-*:2.7.0. 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 che il cambiamento di stato e tutti i callback LifecycleObserver vengano completati prima che vengano restituiti. In particolare, a differenza dell'impostazione diretta della proprietà currentState, questa operazione non utilizza runBlocking, il che lo rende sicuro da utilizzare all'interno di una coroutine come quella fornita da runTest.
• Ora le estensioni LiveData di map e switchMap rispecchiano il comportamento di distinctUntilChanged: se per LiveData è impostato un valore value, la funzione map/switchMap viene chiamata immediatamente per compilare value dell'oggetto LiveData restituito. Ciò garantisce che il valore iniziale venga impostato come parte della prima composizione (se utilizzata con observeAsState()), ma non modifica il comportamento di osservazione: i valori degli aggiornamenti dall'origine LiveData verranno comunque applicati solo una volta che inizierai a osservare il LiveData.
• In questa release è stato corretto un problema per cui SavedStateHandle non ripristinava correttamente le classi Parcelable personalizzate dopo la morte e la ricreazione del processo. A causa delle informazioni sul tipo che vengono perse dal framework Android, gli array di dati Parcelable personalizzati richiedono lavoro aggiuntivo (creazione manuale di un array digitato del tipo corretto) e la documentazione su get, getLiveData e getStateFlow ora richiama in modo specifico questa limitazione.
• Le regole di Keep ProGuard associate a LifecycleObserver sono state rimosse. Ciò significa che il codice protetto che vuole utilizzare le API tramite riflessione (ad esempio utilizzando 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().
• Gli utenti di Jetpack Compose ora possono utilizzare LifecycleEventEffect per eseguire gli effetti collaterali di Compose basati su 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 avviati a arrestati e ripristinati in pausa. Questa API rispecchia quella trovata in DisposableEffect ed è adatta ai casi in cui la modifica apportata quando lo stato aumenta deve essere annullata quando si torna alla versione precedente.

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

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

Osservazione dello stato del ciclo di vita

• L'attuale Lifecycle.State può ora essere osservato tramite la proprietà Lifecycle.currentStateFlow, che restituisce un StateFlow in cui value è l'attuale Lifecycle.State.
• Gli utenti di Jetpack Compose possono utilizzare l'estensione Lifecycle.currentStateAsState() per esporre direttamente Lifecycle.State come Compose State. Questo valore equivale (e un'alternativa più breve) a lifecycle.currentStateFlow.collectAsState().

Per saperne di più, consulta Raccolta dello stato del ciclo di vita con i flussi.

Versione 2.7.0-rc02

13 dicembre 2023

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

Correzioni di bug

• Risolto un problema per cui SavedStateHandle non ripristinava correttamente le classi Parcelable personalizzate dopo la morte e la ricreazione del processo. A causa delle informazioni sul tipo che vengono perse dal framework Android, gli array di dati Parcelable personalizzati richiedono lavoro aggiuntivo (creazione manuale di un array digitato del tipo corretto) e la documentazione su get, getLiveData e getStateFlow ora richiama in modo specifico questa limitazione. (I0b55a).

Versione 2.7.0-rc01

15 novembre 2023

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

Correzioni di bug

• LifecycleStartEffect e LifecycleResumeEffect ora eliminano e ricreano correttamente il blocco degli effetti 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 aumento della versione beta, senza modifiche sostanziali a questa versione di release.

Versione 2.7.0-alpha03

18 ottobre 2023

Viene rilasciato androidx.lifecycle:lifecycle-*:2.7.0-alpha03. 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 valore Lifecycle.State di TestLifecycleOwner utilizzando il campo currentState all'interno di una coroutine. Il controllo Lint ora suggerisce la sospensione di setCurrentState, che consente di impostare Lifecycle.State senza bloccare. (Icf728, b/297880630)

Correzioni di bug

• Risolto un problema con LiveData.switchMap per cui la restituzione della stessa istanza LiveData sia durante la chiamata iniziale che in una chiamata successiva impediva all'istanza LiveData di essere aggiunta come origine. (Ibedcba7)

Versione 2.7.0-alpha02

6 settembre 2023

Viene rilasciato androidx.lifecycle:lifecycle-*:2.7.0-alpha02. 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 da una coroutine come quella fornita da runTest. (I329de, b/259344129)

Modifiche alle API

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

Cambiamenti del comportamento

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

Correzioni di bug

• Da Ciclo di vita 2.6.2: è stato risolto un problema per cui SavedStateHandle non veniva ripristinato correttamente dopo la morte del processo se lo stato fosse ripristinato, per cui save() è stato chiamato senza salvare effettivamente lo stato nell'elemento SavedStateRegistry principale e poi lo stato è stato ripristinato di nuovo. Questa operazione risolve l'interazione tra rememberSaveable e NavHost di Scrittura di navigazione. (aosp/2729289)

Versione 2.7.0-alpha01

26 luglio 2023

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

Modifiche alle API

• Lifecycle.State ora è osservabile in Compose 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 Compose SideEffects in base ai callback di eventi Lifecycle.Event.ON_RESUME e Lifecycle.Event.ON_PAUSE. (I60386, b/235529345)
• È stata aggiunta l'API LifecycleStartEffect per eseguire Compose SideEffects in base ai callback di eventi Lifecycle.Event.ON_START e Lifecycle.Event.ON_STOP. (I5a8d1, b/235529345)
• È stata aggiunta l'API LifecycleEventEffect per eseguire Compose SideEffects in base a Lifecycle.Event. (Ic9794, b/235529345)
• L'estensione Lifecycle.collectAsState() è stata aggiunta per esporre direttamente Lifecycle.State come Scrivi State. Questo valore equivale (e un'alternativa più breve) a lifecycle.currentStateFlow.collectAsState(). (I11015, b/235529345)

Correzioni di bug

• L'estensione LiveData.distinctUntilChanged() ora imposta il value del valore LiveData restituito se per l'elemento LiveData precedente è stato impostato un valore. Ciò non modifica il comportamento di osservazione: i valori aggiornati dall'origine LiveData continueranno a essere applicati solo dopo che avrai iniziato a osservare il valore LiveData restituito da distinctUntilChanged(). (Ib482f)
• Le regole di Keep ProGuard associate a LifecycleObserver sono state rimosse. Ciò significa che il codice protetto che intende utilizzare le API tramite 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

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

Correzioni di bug

• Risolto un problema per cui SavedStateHandle non veniva ripristinato correttamente dopo la morte del processo se lo stato veniva ripristinato, save() veniva chiamato senza salvare effettivamente lo stato nel SavedStateRegistry principale e poi lo stato veniva ripristinato di nuovo. Questa operazione risolve l'interazione tra rememberSaveable e NavHost di Scrittura di navigazione. (aosp/2729289)

Versione 2.6.1

22 marzo 2023

Viene rilasciato androidx.lifecycle:lifecycle-*:2.6.1. 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

Viene rilasciato androidx.lifecycle:lifecycle-*:2.6.0. 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 è mai stato impostato un valore esplicito su LiveData, in modo da distinguere tra liveData.value che restituisce null perché non è mai stato impostato alcun valore o un valore null esplicito.
• MediatorLiveData ora include un costruttore per impostare un valore iniziale.
• È stata aggiunta una nuova estensione su StateFlow e Flow di collectAsStateWithLifecycle() che raccoglie i flussi e 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 poiché l'utilizzo di un supervisore in pausa può comportare lo spreco di risorse in alcuni casi. È consigliabile utilizzare Lifecycle.repeatOnLifecycle. Per ulteriori informazioni sulla sospensione del lavoro una tantum, leggi questa spiegazione sul motivo per cui questo comportamento è intrinsecamente non sicuro.
• Conversione di Kotlin: un numero elevato di classi di Ciclo di vita è stato convertito in Kotlin. Tutte le classi convertite conservano comunque la compatibilità binaria con le versioni precedenti. I seguenti corsi presentano modifiche incompatibili con le fonti per i corsi scritti 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

• Il valore null del metodo onChanged di un elemento Observer creato in Kotlin ora corrisponde a quello del tipo generico. Se vuoi che Observer.onChanged() accetti un tipo null, devi creare un'istanza di Observer con un tipo null.
• Anche questi corsi sono stati convertiti in Kotlin, ma rimangono compatibili con l'origine: DefaultLifecycleObserver, LifecycleEventObserver, Lifecycle, LifecycleRegistry, LifecycleObserver, ViewModelStore, AndroidViewModel, AbstractSavedStateViewModelFactory, LifecycleService, ServiceLifecycleDispatcher e ProcessLifecycleOwner

Versione 2.6.0-rc01

22 febbraio 2023

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

Correzioni di bug

• L'estensione LiveData.distinctUntilChanged() ora imposta il value del valore LiveData restituito se per l'elemento LiveData precedente è stato impostato un valore. Ciò non modifica il comportamento di osservazione: i valori aggiornati dall'origine LiveData continueranno a essere applicati solo dopo che avrai iniziato a osservare il valore LiveData restituito da distinctUntilChanged(). (Ib482f)

Versione 2.6.0-beta01

8 febbraio 2023

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

Conversioni di Kotlin

• LifecycleOwner ora è scritto in Kotlin. Questa è una modifica non compatibile con l'origine per le classi scritte in Kotlin: ora devono eseguire l'override della proprietà lifecycle anziché implementare la funzione getLifecycle() precedente. (I75b4b, b/240298691)
• ViewModelStoreOwner ora è in Kotlin. Questa è una modifica non compatibile con l'origine per le classi scritte in Kotlin: ora devono eseguire l'override della proprietà viewModelStore anziché implementare la funzione getViewModelStore() precedente. (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

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

Conversioni di Kotlin

• Transformations ora è scritto in Kotlin. Si tratta di una modifica incompatibile con le fonti per le classi scritte in Kotlin che utilizzavano direttamente una sintassi come Transformations.map. Il codice Kotlin ora deve utilizzare la sintassi del metodo di estensione Kotlin, che in precedenza era disponibile solo quando si utilizza lifecycle-livedata-ktx. Quando utilizzi il linguaggio di programmazione Java, le versioni di questi metodi che utilizzano un metodo androidx.arch.core.util.Function vengono deprecate 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 incompatibile con le fonti per le classi scritte in Kotlin: ora devi importare e utilizzare direttamente i metodi dell'estensione Kotlin su View di androidx.lifecycle.setViewTreeViewModelStoreOwner e androidx.lifecycle.findViewTreeViewModelStoreOwner per impostare e trovare un proprietario impostato in precedenza. È compatibile con i file 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 non compatibile con l'origine per le classi scritte in Kotlin: ora devono eseguire l'override delle proprietà defaultViewModelProviderFactory e defaultViewModelCreationExtras anziché implementare le funzioni corrispondenti precedenti. (Iaed9c, b/240298691)
• Observer ora è scritto in Kotlin. Il suo metodo onChanged() ora utilizza il nome value per il parametro. (Iffef2, I4995e, b/240298691)
• AndroidViewModel, AbstractSavedStateViewModelFactory, LifecycleService, ServiceLifecycleDispatcher e ProcessLifecycleOwner sono ora scritti in Kotlin (I2e771, Ibae40, I160d7, I08884, I1cda7, b/240298691)

Versione 2.6.0-alpha04

11 gennaio 2023

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

Nuove funzionalità

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

Modifiche alle 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 poiché l'utilizzo di un supervisore in pausa può comportare lo spreco di risorse in alcuni casi. È consigliabile utilizzare Lifecycle.repeatOnLifecycle. (Iafc54, b/248302832)

Conversioni di Kotlin

• ViewTreeLifecycleOwner ora è scritto in Kotlin. Si tratta di una modifica incompatibile con le fonti per le classi scritte in Kotlin: ora devi importare e utilizzare direttamente i metodi dell'estensione Kotlin su View di androidx.lifecycle.setViewTreeLifecycleOwner e androidx.lifecycle.findViewTreeLifecycleOwner per impostare e trovare un proprietario impostato in precedenza. Sostituisce la precedente estensione Kotlin in lifecycle-runtime-ktx. È compatibile con i file 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 non compatibile con l'origine per il codice scritto in Kotlin se non utilizzavi già le API del metodo di estensione Kotlin. (I2b1b9, I95d22, b/240298691)
• DefaultLifecycleObserver, LifecycleEventObserver, Lifecycle, LifecycleRegistry, LifecycleObserver e ViewModelStore sono ora scritti in Kotlin (Iadffd, (I60034, I8c52c, I9593d, I01fe1, I59a230817}/24)

Correzioni di bug

• SavedStateHandle non ha più un arresto anomalo con un ClassCastException quando chiami get() con il tipo di classe errato. (I6ae7c).

Versione 2.6.0-alpha03

24 ottobre 2022

Viene rilasciato androidx.lifecycle:lifecycle-*:2.6.0-alpha03. 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 ha causato l'errore. (Idf4b2, b/244910446)

Versione 2.6.0-alpha02

7 settembre 2022

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

Modifiche alle API

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

Correzioni di bug

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

Versione 2.6.0-alpha01

29 giugno 2022

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

Nuove funzionalità

• È stata aggiunta una nuova estensione su StateFlow e Flow di collectAsStateWithLifecycle che raccoglie dai flussi e 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 del valore 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

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

Correzioni di bug

• Le implementazioni personalizzate di AndroidViewModelFactory ora chiamano correttamente la funzione create(modelClass) quando si utilizza il costruttore AndroidViewModelFactory stateful con Lifecycle 2.4 o versioni successive. (I5b315, b/238011621)

Versione 2.5.0

29 giugno 2022

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

Modifiche importanti dalla versione 2.4.0

• SavedStateHandle ora offre un'API getStateFlow() che restituisce un Kotlin StateFlow per il monitoraggio delle modifiche dei valori in alternativa all'utilizzo di LiveData.

• ViewModel CreationExtras: quando si scrive un elemento ViewModelProvider.Factory personalizzato, non è più necessario estendere AndroidViewModelFactory o AbstractSavedStateViewModelFactory per ottenere l'accesso rispettivamente a Application o SavedStateHandle. 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 le impostazioni 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 Kotlin viewModelFactory che ti consente di definire ViewModelProvider.Factory in termini di uno o più inizializzatori lambda, uno per ogni specifica classe ViewModel 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 richiede una fabbrica lambda per creare un'istanza ViewModel senza richiedere la creazione di una ViewModelProvider.Factory personalizzata.

  // 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 del salvaschermo SavedStateHandle Compose: l'artefatto 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 consentono di aggiungere uno o più oggetti Closeable all'elemento ViewModel che verrà chiuso quando ViewModel verrà cancellato senza richiedere alcun intervento manuale in onCleared().

  Ad esempio, per creare un ambito coroutine che puoi inserire in un ViewModel, ma che può essere controllato tramite 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
  }
  

Cambiamenti del comportamento

• Se provi a spostare Lifecycle.State da INITIALIZED a DESTROYED, ora verrà sempre generato un IllegalStateException, indipendentemente dal fatto che Lifecycle abbia un osservatore collegato.
• Ora LifecycleRegistry cancellerà i propri osservatori quando raggiungeranno lo stato DESTROYED.

Versione 2.5.0-rc02

15 giugno 2022

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

Correzioni di bug

• ViewModelProvider non si arresta in modo più anomalo quando si combinano versioni precedenti delle dipendenze di compileOnly Lifecycle con le versioni 2.5 e successive. (I81a66, b/230454566)

Versione 2.5.0-rc01

11 maggio 2022

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

Correzioni di bug

• MediatorLiveData.addSource() ora genera un NullPointerException quando viene passata un'origine null anziché propagare l'origine null agli osservatori.(Ibd0fb, b/123085232)

Versione 2.5.0-beta01

20 aprile 2022

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

Modifiche alle API

• Sono stati aggiunti i delegati della proprietà SavedStateHandle.saveable per l'utilizzo dei nomi delle proprietà come chiavi per mantenere lo stato in SavedStateHandle (I8bb86, b/225014345)

Correzioni di bug

• È stato risolto un problema per cui la nidificazione di un NavHost all'interno di un altro NavHost in una scheda di navigazione inferiore non principale porta a un IllegalStateException quando vengono utilizzati più gruppi arretrati. (I11bd5, b/228865698)

Versione 2.5.0-alpha06

6 aprile 2022

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

Nuove funzionalità

• Aggiungi il sovraccarico sperimentale di MutableState a SavedStateHandle.saveable per la parità con rememberSaveable (I38cfe, b/224565154)

Modifiche alle 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

Viene rilasciato androidx.lifecycle:lifecycle-*:2.5.0-alpha05. 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 siano integrati correttamente con lo stesso stato di istanza salvato utilizzato da rememberSaveable. (Ia88b7, b/195689777)

Modifiche alle API

• È stato risolto un problema di compatibilità con Lifecycle 2.3 e versioni più recenti del ciclo di vita in Java. (I52c8a, b/219545060)

Correzioni di bug

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

Versione 2.5.0-alpha04

9 marzo 2022

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

Modifiche alle API

• SavedStateHandle ora offre un'API getStateFlow() che restituisce un Kotlin StateFlow per il monitoraggio delle modifiche dei valori come alternativa all'utilizzo di LiveData. (Iad3ab, b/178037961)

Versione 2.5.0-alpha03

23 febbraio 2022

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

Nuove funzionalità

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

Modifiche alle API

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

Cambiamenti del comportamento

• Se provi a spostare Lifecycle.State da INITIALIZED a DESTROYED, ora verrà sempre generato un IllegalStateException, indipendentemente dal fatto che a Lifecycle sia collegato o meno un osservatore. (I7c390, b/177924329)
• Ora LifecycleRegistry cancellerà i propri osservatori quando raggiungerà lo stato DESTROYED. (I4f8dd, b/142925860)

Versione 2.5.0-alpha02

9 febbraio 2022

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

Modifiche alle API

• SavedStateHandle e SavedStateViewModelFactory sono stati convertiti in Kotlin. In questo modo è stato migliorato il valore null dei generici di entrambe le classi. (Ib6ce2, b/216168263, I9647a, b/177667711)
• Ora il parametro della funzione switchMap LiveData può avere un output null. (I40396, b/132923666)
• Le estensioni LiveData -ktx sono ora annotate con @CheckResult per forzare l'utilizzo del risultato quando vengono chiamate queste funzioni. (Ia0f05, b/207325134)

Cambiamenti del comportamento

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

Correzioni di bug

• Da Ciclo di vita 2.4.1: lifecycle-process aggiornato in modo che dipende dall'Avvio 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 viene visualizzato un messaggio di errore migliorato quando i parametri delle classi AndroidViewModel personalizzate hanno i parametri nell'ordine sbagliato e tentano di creare un ViewModel. (I340f7, b/177667711)
• Ora puoi creare un modello di vista tramite CreationExtras utilizzando AndroidViewModelFactory senza impostare un'applicazione. (I6ebef, b/217271656)

Versione 2.5.0-alpha01

26 gennaio 2022

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

ViewModel CreationExtras

Con questa release, gettiamo le basi per ristrutturare la struttura di un ViewModel. Invece di un insieme rigido di sottoclassi di ViewModelProvider.Factory che aggiungono ulteriori funzionalità (consentendo un parametro del costruttore Application tramite AndroidViewModelFactory, consentendo un parametro del costruttore SavedStateHandle tramite SavedStateViewModelFactory e AbstractSavedStateViewModelFactory e così via), ci stiamo spostando verso un mondo di fabbriche stateless che si basano su un nuovo concetto, CreationExtras. (Ia7343, b/188691010, b/188541057)

Con questa modifica, ViewModelProvider non effettua più chiamate dirette al metodo create(Class<T>) precedente di ViewModelProvider.Factory. Chiama invece un nuovo sovraccarico di create: create(Class<T>, CreationExtras). Ciò significa che qualsiasi implementazione diretta dell'istanza ViewModelProvider.Factory ora ha accesso a ciascuna di questi nuovi CreationExtras:

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

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

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

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 createSavedStateHandle() di Kotlin su CreationExtras da SavedStateHandleSupport per creare un SavedStateHandle solo per l'unico ViewModel che lo richiede. (Ia6654, b/188541057)

Il valore CreationExtras personalizzato può essere fornito sostituendo getDefaultViewModelCreationExtras() in ComponentActivity o Fragment, rendendolo così disponibile per il tuo ViewModelProvider.Factory personalizzato come forma di inserimento assistita. Questi extra verranno resi automaticamente disponibili per la tua fabbrica personalizzata se utilizzati direttamente con ViewModelProvider o quando utilizzi le estensioni delle proprietà by viewModels() e by activityViewModels() Kotlin. (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 la morte e la nuova creazione del processo, anche se era stato specificamente rimosso da SavedStateHandle. Di conseguenza, SavedStateHandle non unirà più i valori predefiniti e quelli ripristinati, ma utilizzerà solo i valori ripristinati come origine attendibile. (I53a4b).

Versione 2.4

Versione 2.4.1

9 febbraio 2022

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

Correzioni di bug

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

Versione 2.4.0

27 ottobre 2021

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

Modifiche importanti dalla versione 2.3.0

• @OnLifecycleEvent è stato deprecato. Usa invece LifecycleEventObserver o DefaultLifecycleObserver.
• La raccolta androidx.lifecycle:lifecycle-viewmodel-compose è stata aggiunta. Fornisce viewModel() componibili e LocalViewModelStoreOwner.
  • Modifica che spezza le fonti: ViewModelProvider è stato riscritto in Kotlin. Il metodo ViewModelProvider.Factory.create non consente più l'utilizzo di valori generici con valori null.
• La nuova API coroutines è stata aggiunta a androidx.lifecycle:lifecycle-runtime-ktx:
• 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 verrà riavviato man mano che il ciclo di vita entra ed esce dallo stato target.
• Flow.flowWithLifecycle, API che emette valori dal flusso upstream 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-java8 non fornisce più funzionalità aggiuntive oltre a lifecycle.lifecycle-common, quindi la dipendenza da questo componente può essere sostituita da lifecycle.lifecycle-common.
• L'API non coroutines di lifecycle-viewmodel-ktx è stata spostata nel modulo lifecycle-viewmodel.

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

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

  Se in passato hai utilizzato tools:node="remove", lo ContentProvider utilizzato per inizializzare il ciclo di vita del processo, devi procedere come segue.

   <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 al ciclo di vita 2.4.0-beta01. La versione 2.4.0-rc01 contiene questi commit.

Versione 2.4.0-beta01

15 settembre 2021

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

Modifiche alle API

• @OnLifecycleEvent è stato deprecato. Usa invece LifecycleEventObserver o DefaultLifecycleObserver. (I5a8fa)
• predefinitoLifecycleObserver è stato spostato da androidx.lifecycle.lifecycle-common-java8 a androidx.lifecycle.lifecycle-common. androidx.lifecycle.lifecycle-common-java8 non fornisce più funzionalità aggiuntive oltre a androidx.lifecycle.lifecycle-common, quindi le dipendenze possono essere sostituite da androidx.lifecycle.lifecycle-common. (I021aa)
• L'API non coroutines di lifecycle-viewmodel-ktx è stata spostata nel modulo lifecycle-viewmodel. (I6d5b2).

Contributo esterno

• Grazie dmitrilc per aver corretto un tipo nella documentazione ViewModel. (N. 221)

Versione 2.4.0-alpha03

4 agosto 2021

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

Modifiche alle API

• Modifica che spezza l'origine: il provider ViewModelProvider è stato riscritto in Kotlin. Il metodo ViewModelProvider.Factory.create non consente più l'utilizzo di valori generici con valori null. (I9b9f6)

Cambiamenti del comportamento

• Lifecycle.repeatOnLifecycle: block ora viene sempre richiamato in serie quando si ripete l'esecuzione. (Ibab33)

Contributo esterno

• Grazie chao2zhang per aver corretto gli snippet di codice nella documentazione repeatOnLifecycle. N. 205.

Versione 2.4.0-alpha02

16 giugno 2021

Viene rilasciato androidx.lifecycle:lifecycle-*:2.4.0-alpha02. 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 alle API

• L'API LifecycleOwner.addRepeatingJob viene rimossa a favore di Lifecycle.repeatOnLifecycle, che rispetta la contemporaneità strutturata ed è più facile ragionare. (I4a3a8)
• Rendi ProcessLifecycleInitializer pubblici in modo che altri androidx.startup.Initializer possano utilizzarli come dipendenze. (I94c31)

Correzioni di bug

• È stato risolto un problema relativo al controllo del lint di NullSafeMutableLiveData quando il campo presentava modificatori. (N. 147, b/183696616)
• È stato risolto un altro problema relativo al controllo lint di NullSafeMutableLiveData durante l'utilizzo di termini generici. (N. 161, b/184830263)

Contributo esterno

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

Versione 2.4.0-alpha01

24 marzo 2021

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

Cambiamenti del comportamento

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

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

  Se in passato hai utilizzato tools:node="remove", lo ContentProvider utilizzato per inizializzare il ciclo di vita del processo, devi procedere come segue.

   <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 alle API

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

Correzioni di bug

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

Ciclo di vita Viewmodel Compose versione 1.0.0

Versione 1.0.0-alpha07

16 giugno 2021

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

Modifiche che interessano le API

• viewModel() ora richiede un ViewModelStoreOwner facoltativo, semplificando la collaborazione con proprietari diversi da LocalViewModelStoreOwner. Ad esempio, ora puoi utilizzare viewModel(navBackStackEntry) per recuperare un ViewModel associato a un determinato grafico di navigazione. (I2628d, b/188693123)

Nota: si tratta di una modifica che provoca un'interruzione dei programmi binari. Devi eseguire l'upgrade a Hilt-Navigator-Compose 1.0.0-alpha03 e Navigator Compose 2.4.0-alpha03. Potrebbe trattarsi di una modifica che interrompe la fonte se non hai specificato key = quando utilizzi viewModel(key, factory). Dovresti utilizzare argomenti con nome: viewModel(key = key, factory = factory).

Versione 1.0.0-alpha06

2 giugno 2021

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

Aggiornamento per la compatibilità con Compose versione 1.0.0-beta08.

Versione 1.0.0-alpha05

18 maggio 2021

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

Nuove funzionalità

• Aggiornamento per la compatibilità con Compose versione 1.0.0-beta07.

Correzioni di bug

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

Versione 1.0.0-alpha04

7 aprile 2021

Viene rilasciato androidx.lifecycle:lifecycle-viewmodel-compose:1.0.0-alpha04. 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 la versione 1.0.0, è necessario che il compilatore e il runtime corrispondano.

Versione 1.0.0-alpha03

10 marzo 2021

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

Modifiche alle API

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

Ciclo di vita-Viewmodel-Compose Versione 1.0.0-alpha02

24 febbraio 2021

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

Modifiche alle API

• Ora LocalViewModelStoreOwner ha una funzione provides che può essere utilizzata con CompositionLocalProvider, in sostituzione dell'API asProvidableCompositionLocal(). (I45d24)

Nota: Lifecycle ViewModel Compose 1.0.0-alpha02 è compatibile solo con Compose 1.0.0-beta01.

Ciclo di vita-Viewmodel-Compose Versione 1.0.0-alpha01

10 febbraio 2021

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

Nuove funzionalità

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

Nota: Lifecycle ViewModel Compose 1.0.0-alpha01 è compatibile solo con Compose 1.0.0-alpha12.

Versione 2.3.1

Ciclo di vita versione 2.3.1

24 marzo 2021

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

Correzioni di bug

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

Versione 2.3.0

Versione 2.3.0

10 febbraio 2021

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

Modifiche principali dalla versione 2.2.0

• Supporto di SavedStateHandle per le classi non partizionabili: 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. Consulta Salvataggio di classi non partizionabili.
• Applicazione del comportamento del ciclo di vita:
  • Ora LifecycleRegistry applica DESTROYED come stato terminale.
  • LifecycleRegistry ora verifica che i suoi metodi siano 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 causato arresti anomali difficili da individuare durante il runtime. Per gli oggetti LifecycleRegistry di proprietà dei tuoi componenti, puoi disattivare esplicitamente i controlli utilizzando LifecycleRegistry.createUnsafe(...), ma poi devi assicurarti che venga eseguita una sincronizzazione corretta quando si accede a LifecycleRegistry da diversi thread.
• Assistente dello stato del ciclo di vita e degli eventi: sono stati aggiunti metodi helper statici downFrom(State), downTo(State), upFrom(State), upTo(State) a Lifecycle.Event per generare Event in base a un State e alla direzione della transizione. È stato aggiunto il metodo getTargetState() che fornisce il State a cui verrà trasferito il ciclo di vita subito dopo il Event.
• withStateAtLeast: sono state aggiunte Lifecycle.withStateAtLeast API che attendono uno stato del ciclo di vita ed eseguono un blocco di codice che non sospende la sospensione in modo sincrono al momento del cambiamento di stato, poi riprendono con il risultato. Queste API differiscono dai metodi when* esistenti in quanto non consentono l'esecuzione di codice di sospensione e non impiegano un supervisore personalizzato. (aosp/1326081)
• API ViewTree: le nuove API ViewTreeLifecycleOwner.get(View) e ViewTreeViewModelStoreOwner.get(View) consentono di recuperare, rispettivamente, le LifecycleOwner e ViewModelStoreOwner contenitore, una data istanza View. Per compilare correttamente questi campi, devi eseguire l'upgrade ad Attività 1.2.0, Fragment 1.3.0 e 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.
• LiveData.observe() Ritiro dell'estensione Kotlin: l'estensione LiveData.observe() Kotlin necessaria per usare la sintassi lambda è stata ritirata in quanto non è necessaria quando si usa Kotlin 1.4.

Versione 2.3.0-rc01

16 dicembre 2020

Viene rilasciato androidx.lifecycle:lifecycle-*:2.3.0-rc01. 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 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 sensibili al 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

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

Modifiche alle API

• L'estensione LiveData.observe() Kotlin necessaria per usare la sintassi lambda è ora deprecata in quanto 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

• Lo strumento per la creazione di liveData e i documenti 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

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

Correzioni di bug

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

Versione 2.3.0-alpha06

22 luglio 2020

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

Nuove funzionalità

• Sono stati aggiunti metodi helper statici di downFrom(State), downTo(State), upFrom(State), upTo(State) a Lifecycle.Event per generare Event in base a un State e a una direzione di transizione. È stato aggiunto il metodo getTargetState() che fornisce il State a cui verrà trasferito il ciclo di vita subito dopo il Event. (I00887)
• Sono state aggiunte Lifecycle.withStateAtLeast API che attendono uno stato del ciclo di vita ed eseguono un blocco di codice senza sospensione in modo sincrono al momento del cambiamento di stato, quindi riprendono con il risultato. Queste API differiscono dai metodi when* esistenti in quanto non consentono l'esecuzione di codice di sospensione e non impiegano un supervisore personalizzato. (aosp/1326081)

Cambiamenti del comportamento

• Ora LifecycleRegistry applica DESTROYED come stato terminale. (I00887)
• LifecycleRegistry ora verifica che i suoi metodi siano 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 causato arresti anomali difficili da individuare durante il runtime. Per gli oggetti LifecycleRegistry di proprietà dei tuoi componenti, puoi disattivare esplicitamente i controlli utilizzando LifecycleRegistry.createUnsafe(...), ma poi devi assicurarti che venga eseguita una sincronizzazione corretta quando si accede a 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 nello specifico NullSafeMutableLiveData). (b/158699265)

Versione 2.3.0-alpha05

24 giugno 2020

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

Correzioni di bug

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

Versione 2.3.0-alpha04

10 giugno 2020

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

Correzioni di bug

• È stato risolto un arresto anomalo nel controllo Lint NonNullableMutableLiveData. (b/157294666)
• Il controllo lint NonNullableMutableLiveData ora copre un numero notevolmente maggiore di casi in cui è stato impostato un valore null su un valore MutableLiveData con un parametro di tipo diverso da null. (b/156002218)

Versione 2.3.0-alpha03

20 maggio 2020

Vengono rilasciate le androidx.lifecycle:lifecycle-*:2.3.0-alpha03. 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) ti consente di recuperare l'elemento ViewModelStoreOwner contenitore specificato per un'istanza View. Per completare correttamente i dati, devi eseguire l'upgrade ad Attività 1.2.0-alpha05, Frammento 1.3.0-alpha05 e AppCompat 1.3.0-alpha01. Un'estensione Kotlin findViewModelStoreOwner() è stata aggiunta a lifecycle-viewmodel-ktx. (aosp/1295522).

Correzioni di bug

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

Versione 2.3.0-alpha02

29 aprile 2020

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

Modifiche alle API

• SavedStateViewModelFactory ora ti consente di passare un Application nullo al relativo costruttore per migliorare i casi di assistenza in cui non è immediatamente disponibile e non è necessaria l'assistenza per AndroidViewModel. (aosp/1285740)

Correzioni di bug

• Prestazioni dell'avvio a freddo migliorate evitando errori di verifica della classe su dispositivi con API 28 e versioni precedenti. (aosp/1282118)

Versione 2.3.0-alpha01

4 marzo 2020

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

Nuove funzionalità

• Una nuova API ViewTreeLifecycleOwner.get(View) ti consente di recuperare l'elemento LifecycleOwner contenitore specificato per un'istanza View. Per completare correttamente i dati, devi eseguire l'upgrade ad Attività 1.2.0-alpha01 e Frammento 1.3.0-alpha01. Un'estensione Kotlin findViewTreeLifecycleOwner è disponibile in lifecycle-runtime-ktx. (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 null. Questa opzione è disponibile quando si utilizzano gli artefatti livedata-core-ktx o livedata-ktx. (aosp/1154723, aosp/1159092)
• È disponibile un nuovo artefatto lifecycle-runtime-testing che fornisce un TestLifecycleOwner che implementa LifecycleOwner e fornisce un Lifecycle modificabile con sicurezza in thread. (aosp/1242438)

Correzioni di bug

• L'artefatto lifecycle-runtime ha ora un nome di pacchetto univoco. (aosp/1187196)

Nota: come indicato nelle note di rilascio di 2.2.0 ciclo di vita, l'elemento lifecycle-extensions non è più pubblicato.

Versione 2.2.0

ViewModel-Savedstate versione 2.2.0

5 febbraio 2020

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

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

Versione 2.2.0

22 gennaio 2020

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

Modifiche importanti dalla versione 2.1.0

• Integrazione della corona del ciclo di vita: il nuovo artefatto lifecycle-runtime-ktx aggiunge integrazione tra ciclo di vita e coroutine Kotlin. Inoltre, il lifecycle-livedata-ktx è stato ampliato per sfruttare le coroutine. Per ulteriori dettagli, consulta Utilizzare le coroutine Kotlin con i componenti di architettura.
• Ritiro di ViewModelProviders.of(): il metodo ViewModelProviders.of() è stato deprecato. Puoi passare un valore Fragment o FragmentActivity al nuovo costruttore ViewModelProvider(ViewModelStoreOwner) per ottenere la stessa funzionalità quando utilizzi Frammento 1.2.0.
• Ritiro dell'elemento lifecycle-extensions: a seguito del precedente ritiro di ViewModelProviders.of(), questa release segna il ritiro dell'ultima API in lifecycle-extensions e questo artefatto deve ora essere considerato deprecato nella sua interezza. Ti consigliamo vivamente di utilizzare gli elementi del ciclo di vita specifici di cui hai bisogno (ad esempio lifecycle-service se utilizzi LifecycleService e lifecycle-process se utilizzi ProcessLifecycleOwner) anziché lifecycle-extensions, in quanto non ci sarà una futura release 2.3.0 di lifecycle-extensions.
• Processore di annotazioni incrementali Gradle: il processore di annotazione del ciclo di vita è incrementale per impostazione predefinita. Se la tua app è scritta nel linguaggio di programmazione Java 8, puoi utilizzare DefautLifecycleObserver; se è scritta nel linguaggio di programmazione Java 7, puoi utilizzare LifecycleEventObserver.

Versione 2.2.0-rc03

4 dicembre 2019

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

Correzioni di bug

• È stato corretto un errore che si verificava quando un ViewModel simulato veniva archiviato in ViewModelStore ed eseguito in un secondo momento una query con il valore di fabbrica predefinito.
• Correggi l'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 soluzione. (aosp/1156203)
• Grazie a Vsevolod Tolstopyatov di Jetbrains per aver esaminato l'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

Viene rilasciato androidx.lifecycle:lifecycle-*:2.2.0-rc02. 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 che eseguono l'API 28 o versioni successive se l'API target è inferiore a 29. (b/142778206)

Versione 2.2.0-rc01

23 ottobre 2019

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

Correzioni di bug

• Risolto un problema per cui launchWhenCreated e i metodi correlati venivano eseguiti un frame dopo rispetto al 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 soluzione. (aosp/1145596).

Versione 2.2.0-beta01

9 ottobre 2019

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

Correzioni di bug

• È stata corretta una regressione introdotta in Ciclo di vita 2.2.0-alpha05 nell'ordine di ProcessLifecycleOwner e il passaggio LifecycleOwner dell'attività all'inizio e alla ripresa sui dispositivi Android 10 è stato corretto. (aosp/1128132).
• È stata corretta una regressione introdotta in 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

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

Correzioni di bug

• È stata corretta una condizione di gara nel generatore di dati live di Coroutine. b/140249349

Versione 2.2.0-alpha04

5 settembre 2019

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

Nuove funzionalità

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

Contributi esterni

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

Versione 2.2.0-alpha03

7 agosto 2019

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

Nuove funzionalità

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

Modifiche alle API

• L'API ViewModelProviders.of() è stata deprecata. Puoi passare un valore Fragment o FragmentActivity al nuovo costruttore ViewModelProvider(ViewModelStoreOwner) per ottenere la stessa funzionalità. (aosp/1009889)

Versione 2.2.0-alpha02

2 luglio 2019

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

Modifiche alle API

• È stato sostituito LiveDataScope.initialValue con LiveDataScope.latestValue che monitorerà l'attuale valore emesso del blocco liveData.
• È stato aggiunto un nuovo sovraccarico al generatore liveData che riceve il parametro timeout come tipo Duration

Versione 2.2.0-alpha01

7 maggio 2019

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

Nuove funzionalità

• In questa release sono state aggiunte nuove funzionalità che includono il supporto delle coroutine Kotlin per Lifecycle e LiveData. La documentazione dettagliata è disponibile qui.

ViewModel-SavedState versione 1.0.0

Versione 1.0.0

22 gennaio 2020

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

Funzionalità importanti nella versione 1.0.0

• È stato aggiunto un nuovo corso SavedStateHandle. Consente ai tuoi corsi ViewModel di accedere allo stato salvato e di contribuire allo stato salvato. Questo oggetto può essere ricevuto nel costruttore della classe ViewModel e le fabbriche fornite per impostazione predefinita da Fragments e AppCompatActivity inserirà SavedStateHandle automaticamente.
• AbstractSavedStateViewModelFA è stato aggiunto. 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

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

Modifiche alle dipendenze

• Il valore SavedState di ViewModel del ciclo di vita ora dipende dal ciclo di vita 2.2.0-rc03.

Viewmodel-Savedstate Versione 1.0.0-rc02

7 novembre 2019

Viene rilasciato androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-rc02. 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 dal giorno 1.0.0-beta01. La versione 1.0.0-rc01 contiene questi commit.

ViewModel-Savedstate versione 1.0.0-beta01

9 ottobre 2019

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

Correzioni di bug

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

ViewModel-SavedState versione 1.0.0-alpha05

18 settembre 2019

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

Modifiche alle API

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

ViewModel-SavedState versione 1.0.0-alpha03

7 agosto 2019

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

Modifiche che provocano l'interruzione

• lifecycle-viewmodel-savedstate non dipende più da fragment e i costruttori SavedStateViewModelFactory(Fragment) e SavedStateViewModelFactory(FragmentActivity) correlati sono stati rimossi. Al suo posto, SavedStateViewModelFactory è ora il valore di fabbrica predefinito per Attività 1.1.0-alpha02, Frammento 1.2.0-alpha02 e Navigazione 2.2.0-alpha01. (b/135716331)

ViewModel-SavedState versione 1.0.0-alpha02

2 luglio 2019

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

Nuove funzionalità

• Aggiunto l'overload SavedStateHandle.getLiveData() che accetta un valore predefinito.

Modifiche alle API

• SavedStateVMFactory è stato rinominato in SavedStateViewModelFactory.
• AbstractSavedStateVMFactory è stato rinominato in AbstractSavedStateViewModelFactory.

ViewModel-Savedstate versione 1.0.0-alpha01

13 marzo 2019

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

Nuove funzionalità

• Ora ViewModels può contribuire allo stato salvato. A questo scopo, puoi utilizzare il nuovo valore di fabbrica di viewmodel SavedStateVMFactory e il tuo ViewModel dovrebbe avere un costruttore che riceve SavedStateHandlel'oggetto come parametro.

Versione 2.1.0

Modifiche importanti dalla versione 2.0.0

• È stato aggiunto LifecycleEventObserver per i casi in cui è necessario un flusso di eventi del ciclo di vita. È un'API pubblica anziché una classe GenericLifecycleObserver nascosta.
• Estensioni ktx aggiunte per i metodi LiveData.observe e Transformations.*.
• Transformations.distinctUntilChanged aggiunto, che crea un nuovo oggetto LiveData che non emette un valore finché il valore LiveData di origine non viene modificato.
• È stato aggiunto il supporto della coroutine in ViewModels aggiungendo la proprietà dell'estensione ViewModel.viewModelScope.

Versione 2.1.0

5 settembre 2019

Viene rilasciato androidx.lifecycle:lifecycle-*:2.1.0. 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 dal giorno androidx.lifecycle:*:2.1.0-beta01. I commit inclusi in questa versione sono disponibili qui.

Versione 2.1.0-beta01

7 maggio 2019

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

Nuove funzionalità

• I cicli di vita sono classificati in versione beta: API introdotte nelle versioni alpha precedenti, come le funzioni di estensione liveData per trasformazioni e osservazioni, l'inizializzazione di ViewModel con delega delle proprietà e altre ancora sono stabilizzate e non subiranno modifiche.

Versione 2.1.0-alpha04

3 aprile 2019

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

Nota: ciclo di vita-viewmodel-ktx non è compatibile con le attività dalla versione 1.0.0-alpha01 alla versione 1.0.0-alpha05 e ai frammenti da 1.1.0-alpha01 a 1.1.0-alpha05. Esegui l'upgrade rispettivamente ad Attività 1.0.0-alpha06 e Fragment 1.1.0-alpha06.

Modifiche alle API

• Modifica che provoca un errore: l'API sottostante 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

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

Modifiche alle API

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

Versione 2.1.0-alpha02

30 gennaio 2019

Viene rilasciato androidx.lifecycle 2.1.0-alpha02.

Modifiche alle 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 ViewModel fittizie si arrestavano in modo anomalo dopo la cancellazione dell'elemento ViewModelStore contenitore. b/122273087

Versione 2.1.0-alpha01

17 dicembre 2018

Viene rilasciato androidx.lifecycle 2.1.0-alpha01.

Nuove funzionalità

• È stato aggiunto LifecycleEventObserver per i casi in cui è necessario un flusso di eventi del ciclo di vita. È un'API pubblica anziché una classe GenericLifecycleObserver nascosta.
• Estensioni ktx aggiunte per i metodi LiveData.observe e Transformations.*.
• Il metodo Transformations.distinctUntilChanged è stato aggiunto. Viene creato un nuovo oggetto LiveData che non emette un valore finché il valore LiveData di origine non viene modificato.
• Supporto della coroutine in ViewModels: la proprietà dell'estensione ViewModel.viewModelScope è stata aggiunta.
• È stato aggiunto ViewModelProvider.KeyedFactory, un valore di fabbrica per ViewModels che riceve key e Class nel metodo create.

Versione 2.0.0

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 di proGuard ViewModel che erroneamente rimuoveva i costruttori b/112230489

Versione 2.0.0-beta01

2 luglio 2018

Correzioni di bug

• Fissa la regola di proGuard di LifecycleObserver per mantenere solo le implementazioni, non le sottointerfacce b/71389427
• Correzione delle regole di ProGuard ViewModel per consentire l'offuscamento e la riduzione

Versioni pre-AndroidX

Per le versioni precedenti ad AndroidX del ciclo di vita 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

Una sola piccola modifica: android.arch.core.util.Function è stata spostata da arch:runtime a arch:common. Ciò consente di utilizzarlo senza la dipendenza del runtime, ad esempio nella sezione paging:common di seguito.

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

Versione 1.1.0

22 gennaio 2018

Modifiche alla presentazione

Ora sono disponibili nuove dipendenze molto più piccole:

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

Nota: le estensioni del ciclo di vita 1.0.0 (android.arch.lifecycle:extensions:1.0.0) non sono compatibili con livedata:1.1.0 o viewmodel:1.1.0. Esegui l'aggiornamento a extensions:1.1.0, che include una dipendenza transitiva su livedata:1.1.0 e viewmodel 1.1.0.

Nota: android.arch.lifecycle:reactivestreams:1.1.0 ora dipende solo da android.arch.lifecycle:livedata:1.1.0, non tutti da android.arch.lifecycle:extensions:1.1.0.

Modifiche alle API

• Gli elementi LifecycleActivity e LifecycleFragment deprecati sono stati rimossi. Utilizza FragmentActivity, AppCompatActivity o l'assistenza Fragment.
• @NonNull annotazioni sono state aggiunte a ViewModelProviders e ViewModelStores
• Il costruttore ViewModelProviders è deprecato. Utilizza direttamente i relativi metodi statici
• ViewModelProviders.DefaultFactory è stato deprecato. Utilizza ViewModelProvider.AndroidViewModelFactory
• Il metodo ViewModelProvider.AndroidViewModelFactory.getInstance(Application) statico è stato aggiunto per recuperare un metodo Factory statico adatto alla creazione di istanze ViewModel e AndroidViewModel.