Ciclo di vita

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

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

Elemento Release stabile Candidato per la release Versione beta Release alpha
ciclo di vita-* 2.8.2 - - -
ciclo di vita-vista-modello-componi 2.8.2 - - -
Ultimo aggiornamento di questa raccolta: 12 giugno 2024

Dichiarazione delle dipendenze

Per aggiungere una dipendenza a Ciclo di vita, devi aggiungere il Repository Maven di Google al tuo 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:

Kotlin

trendy

    dependencies {
        def lifecycle_version = "2.8.2"
        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.2"
        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.2"
        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.2"
        val arch_version = "2.2.0"

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

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

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

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

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

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

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

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

Per ulteriori informazioni sulle dipendenze, consulta Aggiungere dipendenze build.

Feedback

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

Crea un nuovo problema

Per ulteriori informazioni, consulta la documentazione di Issue Tracker.

Versione 2.8

Versione 2.8.2

12 giugno 2024

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

Correzioni di bug

  • Sono stati corretti gli errori CompositionLocal LocalLifecycleOwner not present relativi all'utilizzo di Lifecycle 2.8.X con Compose 1.6.X o versioni precedenti. Ora puoi utilizzare Lifecycle 2.8.2 con qualsiasi versione di Compose senza dover ricorrere a soluzioni alternative. (aosp/3105647, b/336842920)
  • ViewModelProvider non si arresta più in modo anomalo quando si combinano le versioni precedenti delle dipendenze del ciclo di vita compileOnly con le versioni 2.8 e successive, risolvendo i problemi con librerie come LeakCanary. (I80383, b/341792251)

Versione 2.8.1

29 maggio 2024

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

Correzioni di bug

  • Ora lifecycle-viewmodel-compose ha una dipendenza comune solo su compose-runtime, rimuovendo la sua dipendenza comune da compose-ui. L'elemento Android conserva il suo compose-ui per motivi di compatibilità. (aosp/3079334, b/339562627)
  • L'integrazione saveable di ViewModel utilizzando delegati di 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

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

Modifiche importanti dalla versione 2.7.0

  • LocalLifecycleOwner è stata spostata dall'interfaccia utente di Compose a lifecycle-runtime-compose in modo che le API helper basate su Compose possano essere utilizzate al di fuori dell'UI di Compose.
  • L'artefatto lifecycle-runtime-compose ora contiene le API dropUnlessResumed e dropUnlessStarted che consentono di ignorare i clic o altri eventi che si verificano anche dopo che il valore di LifecycleOwner è sceso al di sotto del valore Lifecycle.State specificato. Ad esempio, puoi usare questa funzionalità con Scrittura navigazione per evitare di gestire gli eventi di clic dopo che è già iniziata la transizione a un'altra schermata: onClick: () -> Unit = dropUnlessResumed { navController.navigate(NEW_SCREEN) }
  • ViewModel.viewModelScope è ora un parametro del costruttore con override, che ti consente di inserire il tuo supervisore e SupervisorJob() o di sostituire il valore predefinito utilizzando backgroundScope disponibile all'interno di runTest. (I2817c, b/264598574)

    class MyViewModel(
      // Make Dispatchers.Main the default, rather than Dispatchers.Main.immediate
      viewModelScope: CoroutineScope = Dispatchers.Main + SupervisorJob()
    ) : ViewModel(viewModelScope) {
      // Use viewModelScope as before, without any code changes
    }
    
    // Allows overriding the viewModelScope in a test
    fun Test() = runTest {
      val viewModel = MyViewModel(backgroundScope)
    }
    
  • ViewModel è stato riscritto in Kotlin e ora utilizza AutoClosable anziché Closeable. Ora supporta l'aggiunta di oggetti AutoCloseable con un key che consente di recuperarli tramite getCloseable().

  • La chiamata a LifecycleStartEffect e LifecycleResumeEffect senza una chiave ora costituisce un errore, seguendo la stessa convenzione dell'API DisposableEffect di cui queste API eseguono il mirroring.

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

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

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

Compatibilità multipiattaforma Kotlin del ciclo di vita

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

Artefatti interessati:

  • lifecycle-common sposta la maggior parte delle API in common e supporta jvm e iOS oltre ad Android.
  • lifecycle-runtime sposta la maggior parte delle API in common e supporta jvm e iOS oltre ad Android.
  • Ora il campo lifecycle-runtime-ktx è vuoto e tutte le API verranno spostate in lifecycle-runtime.
  • lifecycle-runtime-compose sposta tutte le API in common e spedisce un artefatto Android, in linea con il supporto multipiattaforma di androidx.compose.

Compatibilità multipiattaforma Kotlin ViewModel

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

Per supportare questa modifica, metodi come quelli su ViewModelProvider che hanno richiesto un java.lang.Class<T> ora hanno un metodo equivalente che richiede kotlin.reflect.KClass<T>.

La compatibilità binaria su Android è stata mantenuta, ma sono state apportate alcune modifiche degne di nota quando si confronta la piattaforma API Android con la piattaforma API comune:

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

Artefatti interessati:

  • lifecycle-viewmodel sposta la maggior parte delle API in common e supporta jvm e iOS oltre ad Android.
  • Ora il campo lifecycle-viewmodel-ktx è vuoto e tutte le API verranno spostate in lifecycle-viewmodel.
  • lifecycle-viewmodel-compose sposta tutte le API in common e spedisce un artefatto Android, in linea con il supporto multipiattaforma di androidx.compose.

Modifiche del comportamento

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

Problemi noti

Versione 2.8.0-rc01

1° maggio 2024

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

Correzioni di bug

  • Risolto un problema per cui il profilo di riferimento per le classi lifecycle-common non era pacchettizzato correttamente. Questi dati sono ora pacchettizzati in lifecycle-runtime AAR. (aosp/3038274, b/322382422).
  • È stata corretta una modifica involontaria dell'ordine nel modo in cui le istanze AutoCloseable collegate a un ViewModel vengono cancellate: l'ordine precedente di addCloseable(String, AutoCloseable), poi addClosable(AutoCloseable) e poi onCleared() è stato ripristinato. (aosp/3041632)
  • Migliora il comportamento di creazione predefinito di viewModelScope per gli ambienti nativi e JVM Desktop. (aosp/3039221).

Contributi esterni

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

Versione 2.8.0-beta01

17 aprile 2024

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

Nuove funzionalità

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

Versione 2.8.0-alpha04

3 aprile 2024

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

Nuove funzionalità

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

Correzioni di bug

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

Aggiornamento delle dipendenze

Versione 2.8.0-alpha03

20 marzo 2024

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

Nuove funzionalità

  • ViewModel.viewModelScope è ora un parametro del costruttore con override, che ti consente di inserire il tuo supervisore e SupervisorJob() o di sostituire il valore predefinito utilizzando backgroundScope disponibile all'interno di 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 spediti in artefatti compatibili con Kotlin Multiplatform. (b/214568825)

Per supportare questa modifica, metodi come quelli su ViewModelProvider che hanno richiesto un java.lang.Class<T> ora hanno un metodo equivalente che richiede kotlin.reflect.KClass<T>.

La compatibilità binaria su Android è stata mantenuta, ma sono state apportate alcune modifiche degne di nota quando si confronta la piattaforma API Android con la piattaforma API comune:

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

Modifiche del comportamento

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

Correzioni di bug

  • Ora ViewModel.getCloseable gestisce le chiavi duplicate: se alla risorsa key è già associata una risorsa AutoCloseable, la risorsa precedente verrà sostituita e chiusa immediatamente. (Ibeb67)
  • L'accesso al viewModelScope di ViewModel è ora sicuro tramite thread. (If4766, b/322407038)

Contributi esterni

  • LocalLifecycleOwner è passata dalla UI di Compose a lifestyle-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

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

Nuove funzionalità

  • Sono state aggiunte le API dropUnlessResumed e dropUnlessStarted che consentono di ridurre i clic o altri eventi che si verificano anche quando il valore di LifecycleOwner è sceso al di sotto del valore Lifecycle.State specificato. Ad esempio, puoi utilizzarlo con Scrittura navigazione per evitare di gestire gli eventi di clic dopo che è già iniziata la 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 ora spostate nel modulo Ciclo di vita di base. (Id787b, b/274800183)
  • Le estensioni kotlin lifecycle-runtime-ktx sono state ora spostate nel modulo Ciclo di vita di base. (Ic3686, b/274800183)
  • Le estensioni kotlin lifecycle-livedata-core-ktx sono state ora spostate nel modulo 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 ora vengono spedite in elementi compatibili con Kotlin Multiplatform. (b/317249252)

Modifiche alle API

  • La chiamata a LifecycleStartEffect e LifecycleResumeEffect senza una chiave ora costituisce un errore, seguendo la stessa convenzione dell'API DisposableEffect di cui queste API eseguono il mirroring. (Ib0e0c, b/323518079).
  • ViewModel ora utilizza AutoCloseable anziché Closeable. Questa è una modifica compatibile con le versioni precedenti. (I27f8e, b/214568825).
  • Obsoleto di LiveDataReactiveStreams.toPublisher(lifecycleOwner, liveData) a favore di LiveData.toPublisher(lifecycleOwner). (Iabe29, b/262623005).

Contributi esterni

  • Ringraziamo Ivan Matkov di Jetbrains per aver contribuito al trasferimento del ciclo di vita sul modello Kotlin Multiplatform. (aosp/2926690, I0c5ac, If445d)

Versione 2.8.0-alpha01

24 gennaio 2024

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

Nuove funzionalità

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

Versione 2.7

Versione 2.7.0

10 gennaio 2024

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

Modifiche importanti dalla versione 2.6.0

  • TestLifecycleOwner ora include una funzione di sospensione setCurrentState() che assicura che il cambiamento dello stato e tutti i callback LifecycleObserver vengano completati prima di tornare. In particolare, a differenza dell'impostazione diretta della proprietà currentState, questa operazione non utilizza runBlocking, il che ne rende sicuro l'utilizzo all'interno di una coroutine come quella fornita da runTest.
  • Le estensioni LiveData di map e switchMap ora riflettono il comportamento di distinctUntilChanged. Se LiveData ha un insieme di value, la funzione map/switchMap verrà chiamata immediatamente per compilare il valore value del LiveData restituito. Ciò garantisce che il valore iniziale verrà impostato come parte della prima composizione (se utilizzato con observeAsState()), ma non modifica il comportamento di osservazione: gli aggiornamenti dei valori dall'origine LiveData verranno comunque applicati solo una volta che inizi a osservare il LiveData.
  • In questa release è stato corretto un problema per cui SavedStateHandle non ripristinava correttamente i corsi Parcelable personalizzati dopo l'interruzione del processo e la ricreazione. A causa delle informazioni sul tipo che vengono perse dal framework Android, gli array di Particelle personalizzate richiedono un lavoro aggiuntivo (creazione manuale di un array digitato del tipo giusto) e la documentazione su get, getLiveData e getStateFlow ora chiama in modo specifico questo limite.
  • 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 regole di conservazione proprie per il caso d'uso specifico.

Osservabilità degli eventi del ciclo di vita

  • In alternativa all'utilizzo di 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 effetti collaterali di Compose in base a Lifecycle.Event.
@Composable
fun HomeScreen(viewModel: HomeViewModel = viewModel()) {
  LifecycleEventEffect(Lifecycle.Event.ON_RESUME) {
    viewModel.refreshData()
  }
  // …
}
  • Gli utenti di Jetpack Compose possono utilizzare LifecycleStartEffect e LifecycleResumeEffect per gestire rispettivamente le coppie di eventi, rispettivamente di tipo avviato e ripristinato. 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 indietro.
fun HomeScreen(viewModel: HomeViewModel = viewModel()) {
  LifecycleStartEffect(viewModel) {
    val timeTracking = viewModel.startTrackingTimeOnScreen()
    onStopOrDispose {
      timeTracking.stopTrackingTimeOnScreen()
    }
  }
  // …
}

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

Osservabilità dello stato del ciclo di vita

  • L'attuale Lifecycle.State può ora essere osservato tramite la proprietà Lifecycle.currentStateFlow, che restituisce un StateFlow dove value è l'attuale Lifecycle.State.
  • Gli utenti di Jetpack Compose possono utilizzare l'estensione Lifecycle.currentStateAsState() per esporre direttamente Lifecycle.State come Compose State. 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

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

Correzioni di bug

  • Risolto il problema per cui SavedStateHandle non ripristinava correttamente i corsi Parcelable personalizzati dopo l'interruzione del processo e la ricreazione. A causa delle informazioni sul tipo che vengono perse dal framework Android, gli array di Particelle personalizzate richiedono un lavoro aggiuntivo (creazione manuale di un array digitato del tipo giusto) e la documentazione su get, getLiveData e getStateFlow ora chiama in modo specifico questo limite. (I0b55a).

Versione 2.7.0-rc01

15 novembre 2023

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

Correzioni di bug

  • LifecycleStartEffect e LifecycleResumeEffect ora eliminano e ricreano correttamente il blocco degli effetti se viene modificato LifecycleOwner. (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 picco della versione beta, nessuna modifica importante a questa versione della release.

Versione 2.7.0-alpha03

18 ottobre 2023

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

Nuove funzionalità

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

Correzioni di bug

  • Risolto il problema con LiveData.switchMap per cui la restituzione della stessa istanza LiveData sia nella chiamata iniziale che in quella successiva impedisce l'aggiunta dell'istanza LiveData come origine. (Ibedcba7)

Versione 2.7.0-alpha02

6 settembre 2023

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

Nuove funzionalità

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

Modifiche alle API

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

Modifiche del comportamento

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

Correzioni di bug

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

Versione 2.7.0-alpha01

26 luglio 2023

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

Modifiche alle API

  • Lifecycle.State ora è osservabile tramite Lifecycle.currentStateFlow, che restituisce un StateFlow dove value è l'attuale Lifecycle.State. (Ib212d, b/209684871).
  • Ora è possibile osservare Lifecycle.Event come Flow con Lifecycle.asFlow(). (If2c0f, b/176311030)
  • L'API LifecycleResumeEffect è stata aggiunta per eseguire Compose SideEffect in base ai callback degli eventi Lifecycle.Event.ON_RESUME e Lifecycle.Event.ON_PAUSE. (I60386, b/235529345)
  • L'API LifecycleStartEffect è stata aggiunta per eseguire Compose SideEffect in base ai callback degli eventi Lifecycle.Event.ON_START e Lifecycle.Event.ON_STOP. (I5a8d1, b/235529345).
  • L'API LifecycleEventEffect è stata aggiunta per eseguire Compose SideEffect in base a Lifecycle.Event. (Ic9794, b/235529345)
  • L'estensione Lifecycle.collectAsState() è stata aggiunta per esporre direttamente Lifecycle.State come Compose State. 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 LiveData restituito se è stato impostato un valore per il LiveData precedente. Il comportamento di osservazione non cambia. I valori aggiornati dall'origine LiveData verranno comunque applicati solo una volta che inizierai 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 vuole utilizzare le API mediante riflessione dovrà fornire le proprie regole di conservazione per il suo caso d'uso specifico. (Ia12fd)

Versione 2.6

Versione 2.6.2

6 settembre 2023

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

Correzioni di bug

  • Risolto il 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 nell'elemento SavedStateRegistry principale e poi lo stato veniva ripristinato di nuovo. Questa operazione corregge l'interazione tra rememberSaveable e NavHost di Scrittura di navigazione. (aosp/2729289)

Versione 2.6.1

22 marzo 2023

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

Aggiornamenti delle dipendenze

Versione 2.6.0

8 marzo 2023

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

Modifiche importanti dalla versione 2.5.0

  • LiveData ora include una nuova proprietà isInitialized che indica se è stato impostato un valore esplicito nella LiveData, consentendoti di distinguere tra liveData.value che restituiscono null perché non è mai stato impostato alcun valore o perché è stato impostato 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 dai flussi e rappresenta il suo valore più recente come stato di scrittura 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ò portare a sprechi di risorse in alcuni casi. È consigliabile utilizzare Lifecycle.repeatOnLifecycle. Per ulteriori informazioni sulla sospensione una tantum del lavoro, leggi questa spiegazione sul motivo per cui non è sicuro.
  • Conversione di Kotlin: un numero elevato di classi di ciclo di vita è stato convertito in Kotlin. Tutte le classi convertite mantengono la compatibilità binaria con le versioni precedenti. Le seguenti classi presentano modifiche incompatibili con l'origine per i corsi scritti in Kotlin: ViewTreeLifecycleOwner, LiveDataReactiveStreams, HasDefaultViewModelProviderFactory, ViewTreeViewModelStoreOwner, Transformations, ViewModelStoreOwner e 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
  • Ora il valore nulla del metodo onChanged di un Observer creato in Kotlin corrisponde al valore nulla del metodo generico. Se vuoi che Observer.onChanged() accetti un tipo con valori null, devi creare un'istanza di Observer con un tipo con valore null.
  • Anche queste classi sono state convertite 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

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

Correzioni di bug

  • L'estensione LiveData.distinctUntilChanged() ora imposta il value del LiveData restituito se è stato impostato un valore per il LiveData precedente. Il comportamento di osservazione non cambia. I valori aggiornati dall'origine LiveData verranno comunque applicati solo una volta che inizierai a osservare il valore LiveData restituito da distinctUntilChanged(). (Ib482f)

Versione 2.6.0-beta01

8 febbraio 2023

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

Conversioni di Kotlin

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

Versione 2.6.0-alpha05

25 gennaio 2023

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

Conversioni 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 dell'estensione Kotlin, precedentemente disponibile solo quando si utilizzava lifecycle-livedata-ktx. Quando si utilizza 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 utilizzano un Function1 Kotlin. Questa modifica mantiene la compatibilità binaria. (I8e14f).
  • ViewTreeViewModelStoreOwner è ora scritto in Kotlin. Questa è una modifica incompatibile con l'origine 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. Questo è compatibile con il programma binario ed è comunque compatibile con la sorgente per implementazioni scritte nel linguaggio di programmazione Java. (Ia06d8, Ib22d8, b/240298691)
  • L'interfaccia di HasDefaultViewModelProviderFactory ora è scritta in Kotlin. Si tratta di una modifica incompatibile con l'origine per le classi scritte in Kotlin: ora devono sostituire le proprietà defaultViewModelProviderFactory e defaultViewModelCreationExtras anziché implementare le funzioni corrispondenti precedenti. (Iaed9c, b/240298691).
  • Observer è ora scritto in Kotlin. Il metodo onChanged() ora utilizza il nome value per il parametro. (Iffef2, I4995e, b/240298691).
  • AndroidViewModel, AbstractSavedStateViewModelFactory, LifecycleService, ServiceLifecycleDispatcher e ProcessLifecycleOwner sono ora scritti in Kotlin (I2e771, Ibae40, I160d7, I08884, I1cda7, b/240298691)

Versione 2.6.0-alpha04

11 gennaio 2023

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

Nuove funzionalità

  • LiveData ora include una nuova proprietà isInitialized che indica se è stato impostato un valore esplicito nella LiveData, consentendoti di distinguere tra liveData.value che restituiscono null perché non è mai stato impostato alcun valore o perché è stato impostato 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ò portare a sprechi di risorse in alcuni casi. È consigliabile utilizzare Lifecycle.repeatOnLifecycle. (Iafc54, b/248302832).

Conversioni di Kotlin

  • ViewTreeLifecycleOwner è ora scritto in Kotlin. Questa è una modifica incompatibile con l'origine 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. Questo è compatibile con il programma binario ed è comunque compatibile con la sorgente per implementazioni scritte nel linguaggio di programmazione Java. (I8a77a, I5234e, b/240298691)
  • LiveDataReactiveStreams è ora scritto in Kotlin. Le estensioni Kotlin, in precedenza, in lifecycle-reactivestreams-ktx sono state spostate nel modulo lifecycle-reactivestreams e sono diventate la piattaforma principale per il codice scritto in Kotlin. Si tratta di una modifica incompatibile con 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 ora sono scritte in Kotlin (Iadffd, (I60034, I8c52c, I9593d, I01fe1, I59a23b/6)

Correzioni di bug

Versione 2.6.0-alpha03

24 ottobre 2022

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

Correzioni di bug

  • Risolto il problema relativo ai vincoli tra i 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 li causa. (Idf4b2, b/244910446).

Versione 2.6.0-alpha02

7 settembre 2022

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

Modifiche 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 l'upgrade automatico delle altre dipendenze quando ne viene eseguito l'upgrade. b/242871265
  • FlowLiveData.asFlow() ora crea un callbackFlow invece di 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 o versioni successive (I5b315, b/238011621)

Versione 2.6.0-alpha01

29 giugno 2022

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

Nuove funzionalità

  • È stata aggiunta una nuova estensione su StateFlow e Flow di collectAsStateWithLifecycle che raccoglie dai flussi e rappresenta il suo valore più recente come stato di scrittura 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 rientra almeno in un determinato Lifecycle.State. Quando il ciclo di vita è inferiore a questo valore Lifecycle.State, la raccolta dei flussi si interrompe e il valore dello stato non viene aggiornato. (I1856e, b/230557927)

Versione 2.5

Versione 2.5.1

27 luglio 2022

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

Correzioni di bug

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

Versione 2.5.0

29 giugno 2022

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

Modifiche importanti dalla versione 2.4.0

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

  • ViewModel CreationExtras: quando scrivi un ViewModelProvider.Factory personalizzato, non è più necessario estendere AndroidViewModelFactory o AbstractSavedStateViewModelFactory per ottenere rispettivamente l'accesso 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 dalla tua Attività o Frammento quando utilizzi rispettivamente l'Attività 1.5.0 e il 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 Kotlin DSL viewModelFactory che ti consente di definire ViewModelProvider.Factory in termini di uno o più inizializzatori lambda, uno per ogni specifica classe ViewModel supportata dal tuo produttore personalizzato, utilizzando CreationExtras come origine dati principale.

    val customFactory = viewModelFactory {
        // The return type of the lambda automatically sets what class this lambda handles
        initializer {
            // Get the Application object from extras provided to the lambda
            val application = checkNotNull(get(ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY))
            HomeViewModel(application)
        }
        initializer {
            val savedStateHandle = createSavedStateHandle()
            DetailViewModel(savedStateHandle)
        }
    }
    
  • lifecycle-viewmodel-compose ora offre un'API viewModel() che utilizza una fabbrica lambda per creare un'istanza ViewModel senza richiedere la creazione di un ViewModelProvider.Factory personalizzato.

    // Within a @Composable, you can now skip writing a custom Factory
    // and instead write a lambda to do the initialization of your ViewModel
    val detailViewModel = viewModel {
      // This lambda is only called the first time the ViewModel is created
      // and all CreationExtras are available inside the lambda
      val savedStateHandle = createSavedStateHandle()
      DetailViewModel(savedStateHandle)
    }
    
  • Integrazione del Risparmio di ComposeState: l'elemento lifecycle-viewmodel-compose contiene ora nuove API sperimentali in SavedStateHandle.saveable che consentono a rememberSaveable un comportamento simile 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) }
    }
    
  • Sono stati aggiunti un'API addCloseable() e un nuovo sovraccarico del costruttore che ti consente di aggiungere uno o più oggetti Closeable al ViewModel, che verrà chiuso quando ViewModel verrà cancellato senza richiedere alcuna operazione manuale in onCleared().

    Ad esempio, per creare un ambito a coroutine che puoi inserire in un ViewModel, ma controllarlo tramite test, puoi creare un CoroutineScope che implementi Closeable:

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

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

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

Modifiche del comportamento

  • Ora i tentativi di spostare Lifecycle.State da INITIALIZED a DESTROYED generano sempre un IllegalStateException indipendentemente dal fatto che Lifecycle abbia o meno associato un osservatore.
  • LifecycleRegistry ora cancellerà i propri osservatori quando raggiungerà lo stato DESTROYED.

Versione 2.5.0-rc02

15 giugno 2022

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

Correzioni di bug

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

Versione 2.5.0-rc01

11 maggio 2022

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

Correzioni di bug

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

Versione 2.5.0-beta01

20 aprile 2022

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

Modifiche alle API

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

Correzioni di bug

  • Risolto il problema per cui nidificare un NavHost all'interno di un altro NavHost in una scheda di navigazione inferiore non principale comportava una richiesta IllegalStateException quando si utilizzano più stack posteriori. (I11bd5, b/228865698).

Versione 2.5.0-alpha06

6 aprile 2022

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

Nuove funzionalità

  • Aggiungi l'overload MutableState sperimentale a SavedStateHandle.saveable per la parità con rememberSaveable (I38cfe, b/224565154)

Modifiche alle API

  • CreationExtras ora è astratto e non sigillato. (Ib8a7a).

Correzioni di bug

  • Risolto un errore di IllegalStateException: Already attached to lifecycleOwner causato da SavedStateHandleController. (I7ea47, b/215406268).

Versione 2.5.0-alpha05

23 marzo 2022

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

Nuove funzionalità

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

Modifiche alle API

  • Risolto un problema di compatibilità con le versioni di Ciclo di vita 2.3 e versioni successive in Java. (I52c8a, b/219545060).

Correzioni di bug

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

Versione 2.5.0-alpha04

9 marzo 2022

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

Modifiche alle API

  • SavedStateHandle ora offre un'API getStateFlow() che restituisce un Kotlin StateFlow per monitorare le modifiche ai valori in alternativa all'utilizzo di LiveData. (Iad3ab, b/178037961).

Versione 2.5.0-alpha03

23 febbraio 2022

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

Nuove funzionalità

  • Sono stati aggiunti un'API addCloseable() e un nuovo sovraccarico del costruttore che ti consente di aggiungere uno o più oggetti Closeable al ViewModel, che verrà chiuso quando la proprietà ViewModel verrà cancellata senza richiedere alcun lavoro manuale in onCleared(). (I55ea0)
  • lifecycle-viewmodel ora fornisce un elemento InitializerViewModelFactory che ti 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 utilizza 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 un ViewModel con CreationExtras tramite lifecycle-viewmodel-compose. (I08887, b/216688927)

Modifiche del comportamento

  • Ora i tentativi di spostare Lifecycle.State da INITIALIZED a DESTROYED generano sempre un IllegalStateException indipendentemente dal fatto che Lifecycle abbia o meno associato un osservatore. (I7c390, b/177924329)
  • LifecycleRegistry ora cancellerà i propri osservatori quando raggiungerà lo stato DESTROYED. (I4f8dd, b/142925860).

Versione 2.5.0-alpha02

9 febbraio 2022

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

Modifiche alle API

  • SavedStateHandle e SavedStateViewModelFactory sono stati convertiti in Kotlin. In questo modo è migliorata la nullabilità delle informazioni generiche in entrambe le classi. (Ib6ce2, b/216168263, I9647a, b/177667711)
  • Ora il parametro della funzione switchMap LiveData può avere un output con valore null. (I40396, b/132923666)
  • Le estensioni LiveData -ktx ora sono annotate con @CheckResult per garantire che il risultato venga utilizzato quando si chiamano queste funzioni. (Ia0f05, b/207325134).

Modifiche del comportamento

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

Correzioni di bug

  • Da Ciclo di vita 2.4.1: aggiornamento di lifecycle-process in base all'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).
  • Quando le classi AndroidViewModel personalizzate hanno parametri nell'ordine sbagliato e tentano di creare un ViewModel, ora viene visualizzato un messaggio di errore migliorato. (I340f7, b/177667711)
  • Ora puoi creare un modello di visualizzazione tramite CreationExtras utilizzando AndroidViewModelFactory senza impostare un'applicazione. (I6ebef, b/217271656).

Versione 2.5.0-alpha01

26 gennaio 2022

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

Elementi aggiuntivi Creazione ViewModel

Con questa versione stiamo gettando le basi per ristrutturare la struttura di ViewModel. Anziché un insieme rigido di sottoclassi di ViewModelProvider.Factory che aggiungono ciascuna funzionalità aggiuntiva (consentendo un parametro del costruttore Application tramite AndroidViewModelFactory, consentendo un parametro del costruttore SavedStateHandle tramite SavedStateViewModelFactory e AbstractSavedStateViewModelFactory e così via), ci stiamo spostando in 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 precedente metodo create(Class<T>) di ViewModelProvider.Factory. Invece, chiama in un nuovo sovraccarico di create: create(Class<T>, CreationExtras). Ciò significa che qualsiasi implementazione diretta dell'istanza ViewModelProvider.Factory ha ora accesso a ciascuno di questi nuovi CreationExtras:

  • ViewModelProvider.NewInstanceFactory.VIEW_MODEL_KEY: questo String fornisce l'accesso alla chiave personalizzata che hai trasmesso 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 al Bundle di argomenti che devono essere usati per creare un SavedStateHandle.

Questi extra sono 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 tuo CreationExtras sarà vuoto: tutte le sottoclassi esistenti di ViewModelProvider.Factory sono state riscritte per supportare sia il percorso di creazione legacy utilizzato dalle versioni precedenti di queste librerie sia il percorso CreationExtras che verrà utilizzato in futuro.

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

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

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

Il campo CreationExtras personalizzato può essere fornito eseguendo l'override di getDefaultViewModelCreationExtras() in ComponentActivity o Fragment, rendendolo così disponibile per la tua ViewModelProvider.Factory personalizzata sotto forma di inserimento assistito. Questi extra verranno messi automaticamente a disposizione del tuo produttore personalizzato quando vengono utilizzati direttamente con ViewModelProvider o quando utilizzi le estensioni di proprietà Kotlin by viewModels() e by activityViewModels(). (I79f2b, b/207012584, b/207012585, b/207012490).

Correzioni di bug

  • Risolto il problema per cui il valore predefinito fornito a un SavedStateHandle appariva di nuovo dopo la morte e la ricreazione del processo, anche se era stato specificamente rimosso da SavedStateHandle. Di conseguenza, SavedStateHandle non unisce più i valori predefiniti e quelli ripristinati, ma utilizza solo i valori ripristinati come fonte di riferimento. (I53a4b)

Versione 2.4

Versione 2.4.1

9 febbraio 2022

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

Correzioni di bug

  • Eseguito il backporting da Ciclo di vita 2.5.0-alpha01: è stato risolto un problema per cui il valore predefinito fornito a un SavedStateHandle veniva visualizzato di nuovo dopo la morte e la ricreazione del processo, anche se era stato specificamente rimosso da SavedStateHandle. Di conseguenza, SavedStateHandle non unisce più i valori predefiniti e quelli ripristinati, ma utilizza solo i valori ripristinati come fonte di riferimento. (I53a4b)
  • lifecycle-process ora dipende da Androidx Startup 1.1.1, che ha corretto una regressione in cui l'utilizzo di ProcessLifecycleInitializer causerebbe StartupException. (b/216490724)

Versione 2.4.0

27 ottobre 2021

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

Modifiche importanti dalla versione 2.3.0

  • @OnLifecycleEvent è stato deprecato. Usa invece LifecycleEventObserver o DefaultLifecycleObserver.
  • androidx.lifecycle:lifecycle-viewmodel-compose raccolta aggiunta. Fornisce viewModel() componibile e LocalViewModelStoreOwner.
    • Modifica originale: ViewModelProvider è stato riscritto in Kotlin. Il metodo ViewModelProvider.Factory.create non consente più valori generici con valori null.
  • Una 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 riavviato quando il ciclo di vita si sposta all'interno e all'esterno dello stato di destinazione;
  • 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 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 veniva eseguita da androidx.lifecycle.ProcessLifecycleOwnerInitializer.

    Se in passato hai utilizzato tools:node="remove" ContentProvider per inizializzare il ciclo di vita del processo, devi effettuare le seguenti operazioni:

     <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

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

Modifiche alle API

  • @OnLifecycleEvent è stato deprecato. Usa LifecycleEventObserver o DefaultLifecycleObserver. (I5a8fa)
  • defaultLifecycleObservationr è 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 la dipendenza può essere sostituita da androidx.lifecycle.lifecycle-common. (I021aa)
  • L'API Non coroutines da lifecycle-viewmodel-ktx è stata spostata nel modulo lifecycle-viewmodel. (I6d5b2).

Contributi esterni

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

Versione 2.4.0-alpha03

4 agosto 2021

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

Modifiche alle API

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

Modifiche del comportamento

  • Ora l'elemento Lifecycle.repeatOnLifecycle: block viene sempre richiamato in modo seriale durante la ripetizione dell'esecuzione. (Ibab33)

Contributi esterni

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

Versione 2.4.0-alpha02

16 giugno 2021

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

Nuove funzionalità

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

Modifiche alle API

  • L'API LifecycleOwner.addRepeatingJob è stata rimossa a favore di Lifecycle.repeatOnLifecycle che rispetta la contemporaneità strutturata e semplifica il ragionamento. (I4a3a8).
  • Rendi ProcessLifecycleInitializer pubblico in modo che altri androidx.startup.Initializer possano usarle come dipendenze. (I94c31)

Correzioni di bug

  • Risolto il problema relativo al controllo lint NullSafeMutableLiveData quando il campo contiene modificatori. (#147, b/183696616)
  • È stato risolto un altro problema relativo al controllo lint NullSafeMutableLiveData quando si utilizzano valori generici. (n. 161, b/184830263)

Contributi esterni

Versione 2.4.0-alpha01

24 marzo 2021

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

Modifiche del comportamento

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

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

    Se in passato hai utilizzato tools:node="remove" ContentProvider per inizializzare il ciclo di vita del processo, devi effettuare le seguenti operazioni:

     <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. Si tratta di un'alternativa alla nuova API LifecycleOwner.addRepeatinJob. (I0f4cd)

Correzioni di bug

  • A partire dal ciclo di vita 2.3.1: ora la regola lint NonNullableMutableLiveData può differenziare correttamente le variabili di campo con valori di valori null diversi. (b/169249668)

Lifecycle Viewmodel Compose versione 1.0.0

Versione 1.0.0-alpha07

16 giugno 2021

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

Interruzione delle modifiche all'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).

Versione 1.0.0-alpha06

2 giugno 2021

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

Aggiornato in modo che sia compatibile con la versione 1.0.0-beta08 di Compose.

Versione 1.0.0-alpha05

18 maggio 2021

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

Nuove funzionalità

  • Aggiornato in modo che sia compatibile con la versione 1.0.0-beta07 di Compose.

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

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

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

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

Modifiche alle API

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

Lifecycle-Viewmodel-Compose versione 1.0.0-alpha02

24 febbraio 2021

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

Modifiche alle API

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

Lifecycle-Viewmodel-Compose versione 1.0.0-alpha01

10 febbraio 2021

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

Nuove funzionalità

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

Versione 2.3.1

Ciclo di vita Versione 2.3.1

24 marzo 2021

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

Correzioni di bug

  • La regola lint NonNullableMutableLiveData ora può differenziare correttamente le variabili di campo con valori di valori null diversi. (b/169249668)

Versione 2.3.0

Versione 2.3.0

10 febbraio 2021

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

Importanti modifiche dalla versione 2.2.0

  • Supporto di SavedStateHandle per le classi non comparabili: SavedStateHandle ora supporta la serializzazione lazy consentendo di chiamare setSavedStateProvider() per una determinata chiave, fornendo un SavedStateProvider che riceverà un callback a saveState() quando viene chiesto a SavedStateHandle di salvare il proprio stato. Vedi Salvataggio dei corsi non componibili.
  • Applicazione del comportamento del ciclo di vita:
    • LifecycleRegistry ora applica DESTROYED come stato di terminale.
    • LifecycleRegistry ora verifica che i suoi metodi siano chiamati sul thread principale. È sempre stato un requisito per i cicli di vita delle attività, dei frammenti e così via. L'aggiunta di osservatori dai thread non principali ha reso difficile rilevare gli arresti anomali 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 questo LifecycleRegistry da diversi thread.
  • Aiutanti per lo stato del ciclo di vita e gli eventi: sono stati aggiunti metodi helper statici di downFrom(State), downTo(State), upFrom(State), upTo(State) a Lifecycle.Event per generare Event in base a State e direzione di transizione. È stato aggiunto il metodo getTargetState() che fornisce il valore State a cui passerà il ciclo di vita direttamente dopo Event.
  • withStateAtLeast: sono state aggiunte le API Lifecycle.withStateAtLeast che attendono uno stato del ciclo di vita ed eseguono un blocco di codice non in sospensione in modo sincrono nel momento in cui si cambia lo stato, quindi riprendi con il risultato. Queste API sono diverse dai metodi when* esistenti in quanto non consentono l'esecuzione del codice di sospensione e non utilizzano un supervisore personalizzato. (aosp/1326081).
  • API ViewTree: una nuova API ViewTreeLifecycleOwner.get(View) e ViewTreeViewModelStoreOwner.get(View) ti consente di recuperare rispettivamente le LifecycleOwner e ViewModelStoreOwner contenenti LifecycleOwner e ViewModelStoreOwner in base a un'istanza View. Per compilare correttamente questo campo devi eseguire l'upgrade ad Attività 1.2.0 e Fragment 1.3.0 e ad AppCompat 1.3.0-alpha01 o versioni successive. Le estensioni Kotlin findViewTreeLifecycleOwner e findViewTreeViewModelStoreOwner sono disponibili rispettivamente in lifecycle-runtime-ktx e lifecycle-viewmodel-ktx.
  • LiveData.observe() Ritiro dell'estensione Kotlin: l'estensione Kotlin LiveData.observe() necessaria per utilizzare la sintassi lambda è ora deprecata in quanto non è necessaria quando si utilizza Kotlin 1.4.

Versione 2.3.0-rc01

16 dicembre 2020

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

Correzioni di bug

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

Contributi esterni

Versione 2.3.0-beta01

1° ottobre 2020

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

Modifiche alle API

  • L'estensione Kotlin LiveData.observe() necessaria per utilizzare la sintassi lambda è ora deprecata in quanto non è necessaria quando si utilizza Kotlin 1.4. (I40d3f)

Correzioni di bug

Modifiche alla documentazione

  • Lo strumento per la creazione di liveData e i documenti di asLiveData() sono stati aggiornati per includere dettagli sulla modifica dei valori di timeout specificati. (aosp/1122324).

Versione 2.3.0-alpha07

19 agosto 2020

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

Correzioni di bug

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

Versione 2.3.0-alpha06

22 luglio 2020

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

Nuove funzionalità

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

Modifiche del comportamento

  • LifecycleRegistry ora applica DESTROYED come stato di terminale. (I00887)
  • LifecycleRegistry ora verifica che i suoi metodi siano chiamati sul thread principale. È sempre stato un requisito per i cicli di vita delle attività, dei frammenti e così via. L'aggiunta di osservatori dai thread non principali ha reso difficile rilevare gli arresti anomali 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 questo LifecycleRegistry da diversi thread (Ie7280, b/137392809)

Correzioni di bug

  • Risolto il problema di 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

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

Correzioni di bug

  • LiveData ora gestisce meglio i casi di rientro, evitando chiamate duplicate a onActive() o onInactive(). (b/157840298)
  • Risolto il problema per cui i controlli lint non venivano eseguiti durante l'utilizzo di Android Studio 4.1 Canary 6 o versioni successive. (aosp/1331903)

Versione 2.3.0-alpha04

10 giugno 2020

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

Correzioni di bug

  • È 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 un valore null è stato impostato su MutableLiveData con un parametro di tipo non null. (b/156002218)

Versione 2.3.0-alpha03

20 maggio 2020

androidx.lifecycle:lifecycle-*:2.3.0-alpha03 vengono rilasciati. La versione 2.3.0-alpha03 contiene questi commit.

Nuove funzionalità

  • SavedStateHandle ora supporta la serializzazione lazy permettendoti di chiamare setSavedStateProvider() per una determinata chiave, fornendo un SavedStateProvider che riceverà un callback a saveState() quando viene chiesto all'SavedStateHandle di salvare il proprio stato. (b/155106862)
  • Una nuova API ViewTreeViewModelStoreOwner.get(View) consente di recuperare l'elemento ViewModelStoreOwner contenitore in un'istanza View. Devi eseguire l'upgrade ad Attività 1.2.0-alpha05, Frammento 1.3.0-alpha05 e AppCompat 1.3.0-alpha01 affinché venga compilato correttamente. Un'estensione Kotlin findViewModelStoreOwner() è stata aggiunta a lifecycle-viewmodel-ktx. (aosp/1295522)

Correzioni di bug

  • Risolto un problema che causava la pubblicazione dei controlli Lint MutableLiveData rilasciati nel ciclo di vita 2.3.0-alpha01 insieme all'elemento lifecycle-livedata-core-ktx. (b/155323109)

Versione 2.3.0-alpha02

29 aprile 2020

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

Modifiche alle API

  • SavedStateViewModelFactory ora ti consente di passare un valore Application null al suo costruttore per supportare meglio i casi di assistenza in cui non è immediatamente disponibile e non è necessario il supporto per AndroidViewModel. (aosp/1285740)

Correzioni di bug

  • Sono state migliorate le prestazioni dell'avvio a freddo evitando errori di verifica della classe sui dispositivi con API 28 e versioni precedenti. (aosp/1282118)

Versione 2.3.0-alpha01

4 marzo 2020

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

Nuove funzionalità

  • Una nuova API ViewTreeLifecycleOwner.get(View) consente di recuperare l'elemento LifecycleOwner contenitore in un'istanza View. Devi eseguire l'upgrade all'Attività 1.2.0-alpha01 e al Frammento 1.3.0-alpha01 per compilarlo correttamente. 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 in Kotlin è stato definito 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 sicuro per i thread. (aosp/1242438).

Correzioni di bug

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

Versione 2.2.0

ViewModel-Savedstate Versione 2.2.0

5 febbraio 2020

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

Il modello SaveModel del ciclo di vita ha ora la stessa versione degli altri artefatti del ciclo di vita. Il comportamento di 2.2.0 è identico a quello di 1.0.0.

Versione 2.2.0

22 gennaio 2020

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

Modifiche importanti dalla versione 2.1.0

  • Integrazione delle coroutine nel ciclo di vita: il nuovo artefatto lifecycle-runtime-ktx aggiunge l'integrazione tra Lifecycle e coroutine Kotlin. Anche lifecycle-livedata-ktx è stato ampliato per sfruttare le coroutine. Per ulteriori dettagli, consulta Utilizzare le coroutine Kotlin con componenti di architettura.
  • Ritiro di ViewModelProviders.of(): il servizio ViewModelProviders.of() è stato ritirato. Puoi passare Fragment o FragmentActivity al nuovo costruttore ViewModelProvider(ViewModelStoreOwner) per ottenere la stessa funzionalità quando utilizzi il Frammento 1.2.0.
  • Ritiro dell'elemento lifecycle-extensions: con il precedente ritiro di ViewModelProviders.of(), questa release segna il ritiro dell'ultima API in lifecycle-extensions e questo elemento dovrebbe ora essere considerato deprecato nella sua interezza. Lo consigliamo vivamente a seconda degli elementi specifici del ciclo di vita necessari (ad esempio lifecycle-service se utilizzi LifecycleService e lifecycle-process se utilizzi ProcessLifecycleOwner) anziché lifecycle-extensions, poiché non ci sarà una versione futura di 2.3.0 di lifecycle-extensions.
  • Processore di annotazioni incrementali graduale: il processore di annotazioni 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

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

Correzioni di bug

  • Risolto l'errore che si verificava quando un ViewModel fittizio veniva archiviato in ViewModelStore ed eseguito in un secondo momento una query con il valore di fabbrica predefinito.
  • Correggi un utilizzo di Dispatchers.Main.immediate in launchWhenCreated e in 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 risoluzione del problema. (aosp/1156203).
  • Grazie a Vsevolod Tolstopyatov di Jetbrains per aver esaminato un'implementazione dell'esecuzione integrata.

Modifiche delle dipendenze

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

Versione 2.2.0-rc02

7 novembre 2019

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

Correzioni di bug

  • Risolto un bug nella configurazione ProGuard della libreria che interessava i dispositivi che eseguono l'API 28+ se l'API target è inferiore a 29. (b/142778206)

Versione 2.2.0-rc01

23 ottobre 2019

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

Correzioni di bug

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

Contributi esterni

  • Ringraziamo Nicklas Ansman per aver contribuito alla risoluzione del problema. (aosp/1145596)

Versione 2.2.0-beta01

9 ottobre 2019

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

Correzioni di bug

  • È stata corretta una regressione introdotta in Ciclo di vita 2.2.0-alpha05 nell'ordine di ProcessLifecycleOwner e il valore LifecycleOwner dell'attività veniva avviato e ripreso sui dispositivi Android 10. (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

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

Correzioni di bug

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

Versione 2.2.0-alpha04

5 settembre 2019

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

Nuove funzionalità

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

Contributi esterni

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

Versione 2.2.0-alpha03

7 agosto 2019

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

Nuove funzionalità

Modifiche alle API

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

Versione 2.2.0-alpha02

2 luglio 2019

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

Modifiche 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 di tipo Duration

Versione 2.2.0-alpha01

7 maggio 2019

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

Nuove funzionalità

  • In questa release sono state aggiunte nuove funzionalità che aggiungono 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

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

Funzionalità importanti nella versione 1.0.0

  • È stata aggiunta la nuova classe SavedStateHandle. Consente ai tuoi corsi ViewModel di accedere e contribuire allo stato salvato. Questo oggetto può essere ricevuto nel costruttore della classe ViewModel e nelle fabbriche fornite per impostazione predefinita da Fragments e AppCompatActivity inserirà SavedStateHandle automaticamente.
  • AbstractSavedStateViewModelIndustry è stato aggiunto. In questo modo puoi creare fabbriche personalizzate per il tuo ViewModel e fornire loro l'accesso a SavedStateHandle.

ViewModel-Savedstate Versione 1.0.0-rc03

4 dicembre 2019

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

Modifiche delle dipendenze

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

Viewmodel-Savedstate Versione 1.0.0-rc02

7 novembre 2019

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

Modifiche delle 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 da 1.0.0-beta01. La versione 1.0.0-rc01 contiene questi commit.

ViewModel-Savedstate Versione 1.0.0-beta01

9 ottobre 2019

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

Correzioni di bug

  • Risolto il problema per cui se si accedeva per la prima volta a un SaveState ViewModel in Activity.onActivityResult(), si verificava un errore IllegalStateException. (b/139093676)
  • È stato corretto un IllegalStateException durante l'utilizzo di AbstractSavedStateViewModelFactory. (b/141225984)

ViewModel-SavedState versione 1.0.0-alpha05

18 settembre 2019

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

Modifiche alle API

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

ViewModel-WalletState versione 1.0.0-alpha03

7 agosto 2019

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

Modifiche che provocano un errore

ViewModel-SavedState versione 1.0.0-alpha02

2 luglio 2019

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

Nuove funzionalità

  • È stato aggiunto un sovraccarico di 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

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

Nuove funzionalità

  • Ora ViewModels può contribuire allo stato salvato. A tale scopo, utilizza il nuovo modello di fabbrica SavedStateVMFactory e il tuo ViewModel deve avere un costruttore che riceve l'oggetto SavedStateHandle come parametro.

Versione 2.1.0

Modifiche importanti dalla versione 2.0.0

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

Versione 2.1.0

5 settembre 2019

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

Versione 2.1.0-rc01

2 luglio 2019

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

Versione 2.1.0-beta01

7 maggio 2019

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

Nuove funzionalità

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

Versione 2.1.0-alpha04

3 aprile 2019

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

Modifiche alle API

  • Modifica di interruzione: l'API sottostante dietro by viewModels() e by activityViewModels() è stata modificata per supportare direttamente un ViewModelStore, anziché solo un ViewModelStoreOwner. (aosp/932932)

Versione 2.1.0-alpha03

13 marzo 2019

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

Modifiche alle API

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

Versione 2.1.0-alpha02

30 gennaio 2019

androidx.lifecycle 2.1.0-alpha02 viene rilasciato.

Modifiche alle API

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

Correzioni di bug

  • Risolto il problema per cui le istanze ViewModel fittizie si arrestavano in modo anomalo quando l'elemento ViewModelStore contenitore veniva cancellato. b/122273087

Versione 2.1.0-alpha01

17 dicembre 2018

androidx.lifecycle 2.1.0-alpha01 viene rilasciato.

Nuove funzionalità

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

Versione 2.0.0

Versione 2.0.0

21 settembre 2018

Il ciclo di vita 2.0.0 è stato rilasciato con una correzione di bug di 2.0.0-rc01 in ViewModel.

Correzioni di bug

  • È stata corretta una regola ProGuard ViewModel che ha erroneamente rimosso i costruttori b/112230489

Versione 2.0.0-beta01

2 luglio 2018

Correzioni di bug

  • Correzione della regola Proguard LifecycleObservationr per mantenere solo le implementazioni, non le sottointerfacce b/71389427
  • Sono state corrette le regole di ProGuard di ViewModel per consentire l'offuscamento e la riduzione

Versioni pre-AndroidX

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

Solo una piccola modifica: android.arch.core.util.Function viene spostata da arch:runtime a arch:common. In questo modo può essere utilizzato senza la dipendenza di runtime, ad esempio in paging:common di seguito.

lifecycle:common è una dipendenza di lifecycle:runtime, quindi questa modifica non interessa direttamente lifecycle:runtime, ma solo i moduli che dipendono direttamente da lifecycle:common, come fa l'opzione Paging.

Versione 1.1.0

22 gennaio 2018

Modifiche agli imballaggi

Ora sono disponibili nuove dipendenze molto più piccole:

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

Modifiche alle API

  • Le proprietà LifecycleActivity e LifecycleFragment deprecate sono state rimosse. Utilizza FragmentActivity, AppCompatActivity o l'assistenza Fragment.
  • @NonNull annotazioni sono state aggiunte a ViewModelProviders e ViewModelStores
  • Il costruttore ViewModelProviders è stato deprecato. Usa direttamente i suoi metodi statici
  • L'API ViewModelProviders.DefaultFactory è stata ritirata. Utilizza ViewModelProvider.AndroidViewModelFactory
  • È stato aggiunto il metodo ViewModelProvider.AndroidViewModelFactory.getInstance(Application) statico per recuperare una Factory statica adatta alla creazione di istanze ViewModel e AndroidViewModel.