Se usó la API de Cloud Translation para traducir esta página.

Ciclo de vida

Guía del usuario Muestra de código Codelab

Referencia de la API
androidx.lifecycle

Los componentes optimizados para ciclos de vida realizan acciones como respuesta a un cambio en el estado del ciclo de vida de otro componente, como actividades o fragmentos. Estos componentes te ayudan a crear un código mejor organizado y, a menudo, más liviano, que resulta más fácil de mantener.

En esta tabla, se enumeran todos los artefactos del grupo androidx.lifecycle.

Artefacto	Versión estable	Versión potencial	Versión beta	Versión alfa
lifecycle-*	2.8.7	-	-	2.9.0-alpha07
lifecycle-viewmodel-compose	2.8.7	-	-	2.9.0-alpha07

Esta biblioteca se actualizó por última vez el 13 de noviembre de 2024

Cómo declarar dependencias

Para agregar una dependencia en Lifecycle, debes agregar el repositorio de Maven de Google a tu proyecto. Lee el repositorio de Maven de Google para obtener más información.

Agrega las dependencias de los artefactos que necesites en el archivo build.gradle de tu app o módulo:

Las APIs de lifecycle-extensions dejaron de estar disponibles. En su lugar, agrega dependencias para los artefactos específicos del ciclo de vida que necesites.

Kotlin

Groovy

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

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

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

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

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

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

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

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

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

Kotlin

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

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

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

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

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

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

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

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

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

Java

Groovy

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

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

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

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

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

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

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

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

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

Kotlin

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

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

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

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

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

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

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

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

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

Para obtener más información sobre las dependencias, consulta Cómo agregar dependencias de compilación.

Comentarios

Tus comentarios ayudan a mejorar Jetpack. Avísanos si descubres nuevos errores o tienes ideas para mejorar esta biblioteca. Consulta los errores existentes de esta biblioteca antes de crear uno nuevo. Puedes agregar tu voto a un error existente haciendo clic en el botón de la estrella.

Crear un error nuevo

Consulta la documentación sobre la Herramienta de seguimiento de errores para obtener más información.

Versión 2.9

Versión 2.9.0-alpha07

13 de noviembre de 2024

Lanzamiento de androidx.lifecycle:lifecycle-*:2.9.0-alpha07. La versión 2.9.0-alpha07 contiene estas confirmaciones.

Compatibilidad multiplataforma de Kotlin

Lifecycle ViewModel SavedState ahora es compatible con KMP. Esto te permite usar SavedStateHandle en código común. (Ib6394, b/334076622).

Compatibilidad con la serialización de KotlinX

Con la compatibilidad con la serialización de KotlinX agregada en SavedState 1.3.0-alpha05, presentamos saved, un delegado de propiedades diferido, para facilitar el almacenamiento de clases @Serializable en un SavedStateHandle y hacer que esas clases se restablezcan automáticamente durante la finalización y la recreación del proceso. Ten en cuenta que el delegado saved es diferido y no llamará a la lambda init ni guardará nada en SavedStateHandle hasta que se acceda a él. (I47a88, b/376026744).
```
@Serializable
data class Person(val firstName: String, val lastName: String)

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

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

Cambios en la API

Agrega getMutableStateFlow a SavedStateHandle para mostrar un MutableStateFlow. Esta nueva función es exclusiva de la clave y no se puede usar con getLiveData. Se arrojará una excepción si intentas usar ambos para acceder al mismo estado. (I04a4f, b/375408415).

Versión 2.9.0-alpha06

30 de octubre de 2024

Lanzamiento de androidx.lifecycle:lifecycle-*:2.9.0-alpha06. La versión 2.9.0-alpha06 contiene estas confirmaciones.

Cambios en el comportamiento

El estado Lifecycle.DESTROYED es terminal, y cualquier intento de mover un Lifecycle de él a cualquier otro estado ahora generará un IllegalStateException. (I116c4, b/370577987).
SavedStateHandle ya no incluye ningún SavedStateProvider.saveState() en el que el Bundle que se muestra esté vacío. (I910b5, b/370577987).

Correcciones de errores

Lifecycle.eventFlow ahora se completa correctamente cuando Lifecycle es DESTROYED (I293b2, b/374043130).

Versión 2.9.0-alpha05

16 de octubre de 2024

Lanzamiento de androidx.lifecycle:lifecycle-*:2.9.0-alpha05 sin cambios notables. La versión 2.9.0-alpha05 contiene estas confirmaciones.

Versión 2.9.0-alpha04

2 de octubre de 2024

Lanzamiento de androidx.lifecycle:lifecycle-*:2.9.0-alpha04. La versión 2.9.0-alpha04 contiene estas confirmaciones.

Kotlin multiplataforma

El módulo lifecycle-viewmodel-savedstate ahora está configurado para ser compatible con KMP en preparación para que APIs como SavedStateHandle estén disponibles en el conjunto de fuentes comunes en una versión futura. (I503ed, I48764, b/334076622).

Versión 2.9.0-alpha03

18 de septiembre de 2024

Lanzamiento de androidx.lifecycle:lifecycle-*:2.9.0-alpha03. La versión 2.9.0-alpha03 contiene estas confirmaciones.

Correcciones de errores

A partir de Lifecycle 2.8.6: El error de lint NullSafeMutableLiveData mejoró la compatibilidad con las transmisiones inteligentes, lo que evita los falsos positivos. (85fed6, b/181042665)

Actualizaciones de dependencias

A partir de Lifecycle 2.8.6: Lifecycle Runtime Compose ahora depende de Compose Runtime 1.7.1
El entorno de ejecución de Lifecycle ahora depende de ProfileInstaller 1.4.0.

Versión 2.9.0-alpha02

4 de septiembre de 2024

Lanzamiento de androidx.lifecycle:lifecycle-*:2.9.0-alpha02. La versión 2.9.0-alpha02 contiene estas confirmaciones.

Correcciones de errores

A partir de Lifecycle 2.8.5: Se actualizaron las reglas de ProGuard de androidx.lifecycle.ReportFragment para permitir la ofuscación . (ff898e1).

Contribución externa

Mueve androidx.compose.ui.platform.LocalLifecycleOwner al conjunto de orígenes común (KMP). Gracias a Ivan Matkov de JetBrains por la contribución. (8cd5d03).
A partir de Lifecycle 2.8.5, el delegado de extensión SavedStateHandle.saveable ahora admite valores nulos. Gracias a Roman Kalukiewicz por la contribución. (0d78ea6).

Versión 2.9.0-alpha01

7 de agosto de 2024

Lanzamiento de androidx.lifecycle:lifecycle-*:2.9.0-alpha01. La versión 2.9.0-alpha01 contiene estas confirmaciones.

Kotlin multiplataforma

lifecycle-testing ahora es compatible con KMP. (Iea41e)
Se agregó compatibilidad con el objetivo multiplataforma de Kotlin linuxArm64 (I139d3, b/338268719).

Nuevas funciones

Hay disponible un nuevo artefacto KMP androidx.lifecycle:lifecycle-viewmodel-testing que proporciona una clase ViewModelScenario para probar ViewModels de forma aislada, con compatibilidad con onCleared (todas las plataformas) y SavedStateHandle (solo para Android). (337f68d, c9b3409, 9799a95c, b/264602919).
Crear un ViewModel con ViewModelProvider ahora es seguro para subprocesos. Se quitaron las anotaciones @MainThread. (Ifd978, b/237006831).

Cambios en la API

Agrega la función de fábrica CreationExtras.Key() para simplificar la creación de objetos CreationExtras.Key anónimos. (I970ee).
CreationExtras ahora incluye sobrecargas de operadores similares a mapas para permitir la manipulación idiomática del contenido en Kotlin. Permite el uso de in, += y + con CreationExtras. (Ib4353).
CreationExtras ahora implementa los métodos equals, hashCode y toString. (Ib4353).
NewInstanceFactory ahora está disponible en los destinos de JVM para computadoras y Android. (d3d0892).
Propiedad de extensión intercalada para exponer la aplicación subyacente de forma segura en la versión 2.0 del lenguaje Kotlin (I39df2).

Correcciones de errores

Se quitó el esquema manual de acceso a las nuevas APIs de la plataforma, ya que esto se realiza automáticamente a través del modelado de API cuando se usa R8 con AGP 7.3 o versiones posteriores (p.ej., R8 versión 3.3) y para todas las compilaciones cuando se usa AGP 8.1 o versiones posteriores (p.ej., D8 versión 8.1). Se recomienda a los clientes que no usen AGP que actualicen a la versión 8.1 de D8 o una posterior. Consulta este artículo para obtener más detalles. (If6b4c, b/345472586).

Versión 2.8

Versión 2.8.7

30 de octubre de 2024

Lanzamiento de androidx.lifecycle:lifecycle-*:2.8.7. La versión 2.8.7 contiene estas confirmaciones.

Cambios en la API

androidx.compose.ui.platform.LocalLifecycleOwner ahora está disponible en el conjunto de fuentes común (KMP). (6a3f5b3).
lifecycle-runtime-compose: Se quitaron los artefactos desktop y se agregaron los artefactos -jvmStubs y -linuxx64Stubs. Ninguno de estos objetivos está destinado a usarse, son marcadores de posición para ayudar a los esfuerzos de Jetbrains Compose. (6a3f5b3).

Versión 2.8.6

18 de septiembre de 2024

Lanzamiento de androidx.lifecycle:lifecycle-*:2.8.6. La versión 2.8.6 contiene estas confirmaciones.

Correcciones de errores

El error de lint NullSafeMutableLiveData mejoró la compatibilidad con las transmisiones inteligentes, lo que evita los falsos positivos. (85fed6, b/181042665)

Actualizaciones de dependencias

Lifecycle Runtime Compose ahora depende de Compose Runtime 1.7.1.

Versión 2.8.5

4 de septiembre de 2024

Lanzamiento de androidx.lifecycle:lifecycle-*:2.8.5. La versión 2.8.5 contiene estas confirmaciones.

Correcciones de errores

Se actualizaron las reglas de ProGuard de androidx.lifecycle.ReportFragment para permitir la ofuscación . (ff898e1).

Contribución externa

El delegado de extensión SavedStateHandle.saveable ahora admite valores anulables. Gracias a Roman Kalukiewicz por la contribución. (0d78ea6).

Versión 2.8.4

24 de julio de 2024

Lanzamiento de androidx.lifecycle:lifecycle-*:2.8.4. La versión 2.8.4 contiene estas confirmaciones.

Correcciones de errores

LiveData.asFlow() ahora controla correctamente los casos en los que el flujo que se muestra se completa de inmediato después de recibir un valor que ya se configuró en LiveData (por ejemplo, cuando se usa take(1)). (I9c566)
La finalización de Lifecycle*Effect ahora es idempotente (es decir, si se llamó a onStopOrDispose debido a que se detuvo el ciclo de vida, no se volverá a llamar por segunda vez cuando se descarte, a menos que el ciclo de vida vuelva a STARTED). (I5f607, b/352364595).

Versión 2.8.3

1 de julio de 2024

Lanzamiento de androidx.lifecycle:lifecycle-*:2.8.3. La versión 2.8.3 contiene estas confirmaciones.

Correcciones de errores

Se solucionó un problema con la compatibilidad con versiones anteriores de Lifecycle 2.8 con Compose 1.6.0 y versiones anteriores cuando se usaba la reducción de código. (aosp/3133056, b/346808608).

Versión 2.8.2

12 de junio de 2024

Lanzamiento de androidx.lifecycle:lifecycle-*:2.8.2. La versión 2.8.2 contiene estas confirmaciones.

Correcciones de errores

Se corrigieron los errores de CompositionLocal LocalLifecycleOwner not present cuando se usaba Lifecycle 2.8.X con Compose 1.6.X o versiones anteriores. Ahora puedes usar Lifecycle 2.8.2 con cualquier versión de Compose sin necesidad de soluciones alternativas. (aosp/3105647, b/336842920)
ViewModelProvider ya no fallará cuando se combinen versiones anteriores de dependencias de Lifecycle de compileOnly con versiones 2.8 y posteriores, lo que corrige problemas con bibliotecas como LeakCanary. (I80383, b/341792251).

Versión 2.8.1

29 de mayo de 2024

Lanzamiento de androidx.lifecycle:lifecycle-*:2.8.1. La versión 2.8.1 contiene estas confirmaciones.

Correcciones de errores

lifecycle-viewmodel-compose ahora solo tiene una dependencia común en compose-runtime, lo que quita su dependencia común en compose-ui. El artefacto de Android retiene su compose-ui para la compatibilidad. (aosp/3079334, b/339562627).
La integración de saveable de ViewModel con delegados de propiedades ahora usa el nombre de la clase como parte de la clave generada automáticamente, lo que evita conflictos si varias clases usan el mismo SavedStateHandle. (aosp/3063463)

Versión 2.8.0

14 de mayo de 2024

Lanzamiento de androidx.lifecycle:lifecycle-*:2.8.0. La versión 2.8.0 contiene estas confirmaciones.

Cambios importantes desde 2.7.0

LocalLifecycleOwner se trasladó de la IU de Compose a lifecycle-runtime-compose para que sus APIs de ayuda basadas en Compose se puedan usar fuera de la IU de Compose.
El artefacto lifecycle-runtime-compose ahora contiene las APIs de dropUnlessResumed y dropUnlessStarted, que te permiten soltar clics o bien otros eventos que ocurren incluso después de que LifecycleOwner disminuya por debajo del Lifecycle.State determinado. Por ejemplo, esto se puede usar con Navigation Compose para evitar controlar los eventos de clic después de que ya comenzó una transición a otra pantalla: onClick: () -> Unit = dropUnlessResumed { navController.navigate(NEW_SCREEN) }

ViewModel.viewModelScope ahora es un parámetro de constructor anulable, lo que te permite insertar tu propio despachador y SupervisorJob(), o bien anular el valor predeterminado con el backgroundScope disponible en 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 se reescribió en Kotlin y ahora usa AutoClosable en lugar de Closeable. Ahora admite la adición de objetos AutoCloseable con un key que permite recuperarlos a través de getCloseable().
Llamar a LifecycleStartEffect y LifecycleResumeEffect sin una clave ahora es un error, siguiendo la misma convención que la API de DisposableEffect que estas APIs reflejan.
LiveDataReactiveStreams.toPublisher(lifecycleOwner, liveData) dejó de estar disponible y se reemplazó por LiveData.toPublisher(lifecycleOwner).
Las extensiones de Kotlin lifecycle-livedata-core-ktx ahora se trasladaron al módulo lifecycle-livedata-core.
Se refactorizó NullSafeMutableLiveData para evitar muchos falsos positivos.

Compatibilidad multiplataforma de Kotlin con el ciclo de vida

Las APIs principales de Lifecycle en Lifecycle, LifecycleOwner, LifecycleObserver, Lifecycle.State, Lifecycle.Event y LifecycleRegistry ahora se envían en artefactos compatibles con Kotlin Multiplatform.

Artefactos afectados:

lifecycle-common traslada la mayoría de las APIs a common y admite jvm y iOS, además de Android.
lifecycle-runtime traslada la mayoría de las APIs a common y admite jvm y iOS, además de Android.
lifecycle-runtime-ktx ahora está vacío, y todas las APIs se trasladaron a lifecycle-runtime.
lifecycle-runtime-compose traslada todas las APIs a common y envía un artefacto de Android que coincide con la compatibilidad multiplataforma de androidx.compose.

Compatibilidad multiplataforma de Kotlin con ViewModel

El artefacto lifecycle-viewmodel y las APIs como ViewModel, ViewModelStore, ViewModelStoreOwner y ViewModelProvider ahora se envían en artefactos compatibles con Kotlin Multiplatform.

Para adaptarse a este cambio, los métodos como los de ViewModelProvider que tomaban un java.lang.Class<T> ahora tienen un método equivalente que toma un kotlin.reflect.KClass<T>.

Se mantuvo la compatibilidad binaria en Android, pero hay algunos cambios notables cuando se compara la plataforma de la API de Android con la plataforma de la API común:

La construcción de una instancia de ViewModelProvider ahora se realiza a través de los métodos ViewModelProvider.create() en lugar de llamar directamente a su constructor.
ViewModelProvider.NewInstanceFactory y ViewModelProvider.AndroidViewModelFactory solo están disponibles en Android.
- Se recomienda que las fábricas personalizadas se extiendan desde ViewModelProvider.Factory y usen el método create que toma un CreationExtras o usen el DSL de Kotlin viewModelFactory.
El uso de ViewModelProvider sin una fábrica personalizada en plataformas que no sean JVM generará un UnsupportedOperationException. En las plataformas de JVM, la compatibilidad se conserva mediante el uso del constructor de ViewModel sin argumentos si no se proporciona una fábrica personalizada.
viewModelScope recurrirá a un EmptyCoroutineContext en plataformas donde Dispatchers.Main no esté disponible (p.ej., Linux).

Artefactos afectados:

lifecycle-viewmodel traslada la mayoría de las APIs a common y admite jvm y iOS, además de Android.
lifecycle-viewmodel-ktx ahora está vacío, y todas las APIs se trasladaron a lifecycle-viewmodel.
lifecycle-viewmodel-compose traslada todas las APIs a common y envía un artefacto de Android que coincide con la compatibilidad multiplataforma de androidx.compose.

Cambios en el comportamiento

InitializerViewModelFactory (incluida la función del compilador viewModelFactory) ahora arrojará una IllegalArgumentException si ya se agregó un initializer con el mismo clazz: KClass<VM : ViewModel>. (Ic3a36)

Errores conocidos

lifecycle-*:2.8.0 requiere una versión mínima de Compose 1.7.0-alpha05 (b/336842920).

Versión 2.8.0-rc01

1 de mayo de 2024

Lanzamiento de androidx.lifecycle:lifecycle-*:2.8.0-rc01. La versión 2.8.0-rc01 contiene estas confirmaciones.

Correcciones de errores

Se corrigió un problema por el que el perfil de Baseline para las clases lifecycle-common no se empaquetaba correctamente. Ahora se empaquetan en el AAR lifecycle-runtime. (aosp/3038274, b/322382422).
Se corrigió un cambio de orden no intencional en la forma en que se borran las instancias de AutoCloseable adjuntas a un ViewModel. Se restableció el orden anterior de addCloseable(String, AutoCloseable), luego addClosable(AutoCloseable) y, luego, onCleared(). (aosp/3041632).
Se mejoró el comportamiento de creación predeterminado de viewModelScope para entornos de escritorio nativos y de JVM. (aosp/3039221).

Contribución externa

Gracias Victor Kropp por mejorar la verificación del subproceso principal en JVM Desktop. (aosp/3037116).

Versión 2.8.0-beta01

17 de abril de 2024

Lanzamiento de androidx.lifecycle:lifecycle-*:2.8.0-beta01. La versión 2.8.0-beta01 contiene estas confirmaciones.

Nuevas funciones

El artefacto lifecycle-runtime-compose ahora es compatible con Kotlin multiplataforma, traslada su código a common y envía un artefacto de Android, que coincide con la compatibilidad multiplataforma de androidx.compose. (If7a71, I4f4a0, b/331769623).

Versión 2.8.0-alpha04

3 de abril de 2024

Lanzamiento de androidx.lifecycle:lifecycle-*:2.8.0-alpha04. La versión 2.8.0-alpha04 contiene estas confirmaciones.

Nuevas funciones

El artefacto lifecycle-viewmodel-compose ahora es compatible con Kotlin multiplataforma, traslada su código a common y envía un artefacto de Android, que coincide con la compatibilidad multiplataforma de androidx.compose. Para adaptarse a este cambio, el método viewModel de componibilidad ahora acepta un KClass además de un java.lang.Class. (b/330323282).

Correcciones de errores

Se refactorizó NullSafeMutableLiveData para evitar muchos falsos positivos. (I2d8c1, Iafb18, I03463, I7ecef).

Actualización de dependencia

El artefacto lifecycle-viewmodel-compose ahora depende de Compose 1.6.0.
Lifecycle ahora depende de Profile Installer 1.3.1.

Versión 2.8.0-alpha03

20 de marzo de 2024

Lanzamiento de androidx.lifecycle:lifecycle-*:2.8.0-alpha03. La versión 2.8.0-alpha03 contiene estas confirmaciones.

Nuevas funciones

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)
}

Compatibilidad multiplataforma de Kotlin

El artefacto lifecycle-viewmodel y las APIs como ViewModel, ViewModelStore, ViewModelStoreOwner y ViewModelProvider ahora se envían en artefactos compatibles con Kotlin Multiplatform. (b/214568825)

Para adaptarse a este cambio, los métodos como los de ViewModelProvider que tomaban un java.lang.Class<T> ahora tienen un método equivalente que toma un kotlin.reflect.KClass<T>.

Se mantuvo la compatibilidad binaria en Android, pero hay algunos cambios notables cuando se compara la plataforma de la API de Android con la plataforma de la API común:

La construcción de una instancia de ViewModelProvider ahora se realiza a través de los métodos ViewModelProvider.create() en lugar de llamar directamente a su constructor.
ViewModelProvider.NewInstanceFactory y ViewModelProvider.AndroidViewModelFactory solo están disponibles en Android.
- Se recomienda que las fábricas personalizadas se extiendan desde ViewModelProvider.Factory y usen el método create que toma un CreationExtras o usen el DSL de Kotlin viewModelFactory.
El uso de ViewModelProvider sin una fábrica personalizada en plataformas que no sean JVM generará un UnsupportedOperationException. En las plataformas de JVM, la compatibilidad se conserva mediante el uso del constructor de ViewModel sin argumentos si no se proporciona una fábrica personalizada.
viewModelScope recurrirá a un EmptyCoroutineContext en plataformas donde Dispatchers.Main no esté disponible (p.ej., Linux).

Cambios en el comportamiento

InitializerViewModelFactory (incluida la función del compilador viewModelFactory) ahora arrojará una IllegalArgumentException si ya se agregó un initializer con el mismo clazz: KClass<VM : ViewModel>. (Ic3a36)

Correcciones de errores

ViewModel.getCloseable ahora controla las claves duplicadas: si el key ya tiene un recurso AutoCloseable asociado, el recurso anterior se reemplazará y se cerrará de inmediato. (Ibeb67).
El acceso a viewModelScope de un ViewModel ahora es seguro para subprocesos. (If4766, b/322407038).

Contribución externa

LocalLifecycleOwner se trasladó de la IU de Compose a lifecycle-runtime-compose para que sus APIs de ayuda basadas en Compose se puedan usar fuera de la IU de Compose. Gracias Jake Wharton por la contribución. (I6c41b, b/328263448).

Versión 2.8.0-alpha02

21 de febrero de 2024

Lanzamiento de androidx.lifecycle:lifecycle-*:2.8.0-alpha02. La versión 2.8.0-alpha02 contiene estas confirmaciones.

Nuevas funciones

Se agregaron las APIs de dropUnlessResumed y dropUnlessStarted, que te permiten descartar clics y otros eventos que ocurren incluso después de que LifecycleOwner disminuya por debajo del Lifecycle.State determinado. Por ejemplo, se puede usar con Navigation Compose para evitar controlar eventos de clic después de que ya comenzó una transición a otra pantalla: onClick: () -> Unit = dropUnlessResumed { navController.navigate(NEW_SCREEN) } (Icba83, b/317230685).

Conversiones de Kotlin

Ahora, ViewModel está escrito en Kotlin (I16f26, b/214568825).
Las extensiones de Kotlin lifecycle-viewmodel-ktx ahora se trasladaron al módulo de ciclo de vida base. (Id787b, b/274800183).
Las extensiones de Kotlin lifecycle-runtime-ktx ahora se trasladaron al módulo de ciclo de vida base. (Ic3686, b/274800183).
Las extensiones de Kotlin lifecycle-livedata-core-ktx ahora se trasladaron al módulo de ciclo de vida base. (I54a3d, b/274800183)

Compatibilidad multiplataforma de Kotlin

Las APIs principales de Lifecycle en Lifecycle, LifecycleOwner, LifecycleObserver, Lifecycle.State, Lifecycle.Event y LifecycleRegistry ahora se envían en artefactos compatibles con Kotlin Multiplatform. (b/317249252).

Cambios en la API

Llamar a LifecycleStartEffect y LifecycleResumeEffect sin una clave ahora es un error, siguiendo la misma convención que la API de DisposableEffect que estas APIs reflejan. (Ib0e0c, b/323518079).
ViewModel ahora usa AutoCloseable en lugar de Closeable. Ese es un cambio retrocompatible. (I27f8e, b/214568825).
LiveDataReactiveStreams.toPublisher(lifecycleOwner, liveData) dejó de estar disponible y se reemplazó por LiveData.toPublisher(lifecycleOwner). (Iabe29, b/262623005).

Contribución externa

Gracias a Ivan Matkov de Jetbrains por ayudar a trasladar Lifecycle a Kotlin multiplataforma. (aosp/2926690, I0c5ac, If445d)

Versión 2.8.0-alpha01

24 de enero de 2024

Lanzamiento de androidx.lifecycle:lifecycle-*:2.8.0-alpha01. La versión 2.8.0-alpha01 contiene estas confirmaciones.

Nuevas funciones

ViewModel ahora admite la adición de objetos Closeable con un key que permite recuperarlos a través de getCloseable(). (I3cf63)

Versión 2.7

Versión 2.7.0

10 de enero de 2024

Lanzamiento de androidx.lifecycle:lifecycle-*:2.7.0. La versión 2.7.0 contiene estas confirmaciones.

Cambios importantes desde la versión 2.6.0

TestLifecycleOwner ahora incluye una función de suspensión setCurrentState() que garantiza que el cambio de estado y todas las devoluciones de llamada de LifecycleObserver se completen antes de mostrarse. En particular, a diferencia de establecer la propiedad currentState directamente, no se usa runBlocking, lo que lo hace seguro para usar dentro de una corrutina, como la que proporciona runTest.
Las extensiones LiveData de map y switchMap ahora reflejan el comportamiento de distinctUntilChanged. Si LiveData tiene un value establecido, se llamará de inmediato a la función map/switchMap para propagar el value del LiveData que se muestra. Esto garantiza que el valor inicial se establezca como parte de la primera composición (cuando se usa con observeAsState()), pero no cambia el comportamiento de observación: las actualizaciones de los valores de la fuente LiveData solo se aplicarán una vez que comiences a observar el LiveData.
Esta versión corrige un problema por el que SavedStateHandle no restablecía correctamente las clases Parcelable personalizadas después del cierre y la recreación del proceso. Debido a la información de tipo que pierde el framework de Android, los arrays de Parcelables personalizados requieren trabajo adicional (crear manualmente un array escrito del tipo correcto) y la documentación sobre get, getLiveData y getStateFlow ahora menciona específicamente esta limitación.
Se quitaron las reglas de retención de Proguard asociadas con LifecycleObserver. Esto significa que el código proguardado que desee usar APIs a través de la reflexión (como usar la anotación @OnLifecycleEvent, que dejó de estar disponible hace mucho tiempo) deberá proporcionar sus propias reglas de conservación para su caso de uso específico.

Observabilidad de eventos del ciclo de vida

Como alternativa al uso de un LifecycleEventObserver, ahora puedes observar un Flow de Lifecycle.Event a través del método de extensión Lifecycle.asFlow().
Los usuarios de Jetpack Compose ahora pueden usar LifecycleEventEffect para ejecutar efectos secundarios de Compose basados en Lifecycle.Event.

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

Los usuarios de Jetpack Compose pueden usar LifecycleStartEffect y LifecycleResumeEffect para controlar pares de eventos: de iniciado a detenido y de reanudado a detenido, respectivamente. Esta API refleja la que se encuentra en DisposableEffect y es adecuada para los casos en los que el cambio que se realiza cuando el estado aumenta debe revertirse cuando vuelve a disminuir.

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

Consulta Cómo ejecutar código en eventos de ciclo de vida para obtener más información.

Observabilidad del estado del ciclo de vida

El Lifecycle.State actual ahora se puede observar a través de la propiedad Lifecycle.currentStateFlow, que muestra un StateFlow en el que value es el Lifecycle.State actual.
Los usuarios de Jetpack Compose pueden usar la extensión Lifecycle.currentStateAsState() para exponer directamente Lifecycle.State como State de Compose. Esto equivale (y es una alternativa más corta) a lifecycle.currentStateFlow.collectAsState().

Consulta Cómo recopilar el estado del ciclo de vida con flujos para obtener más información.

Versión 2.7.0-rc02

13 de diciembre de 2023

Lanzamiento de androidx.lifecycle:lifecycle-*:2.7.0-rc02. La versión 2.7.0-rc02 contiene estas confirmaciones.

Correcciones de errores

Se corrigió un problema por el que SavedStateHandle no restablecía correctamente las clases Parcelable personalizadas después del cierre y la recreación del proceso. Debido a la información de tipo que pierde el framework de Android, los arrays de Parcelables personalizados requieren trabajo adicional (crear manualmente un array escrito del tipo correcto) y la documentación sobre get, getLiveData y getStateFlow ahora menciona específicamente esta limitación. (I0b55a).

Versión 2.7.0-rc01

15 de noviembre de 2023

Lanzamiento de androidx.lifecycle:lifecycle-*:2.7.0-rc01. La versión 2.7.0-rc01 contiene estas confirmaciones.

Correcciones de errores

LifecycleStartEffect y LifecycleResumeEffect ahora descartan y vuelven a crear correctamente el bloque de efectos si se cambia LifecycleOwner. (Ia25c6).

Versión 2.7.0-beta01

1 de noviembre de 2023

Se lanzó androidx.lifecycle:lifecycle-*:2.7.0-beta01 sin cambios. La versión 2.7.0-beta01 contiene estas confirmaciones.

Es un aumento de versión beta, sin cambios importantes en esta versión de actualización.

Versión 2.7.0-alpha03

18 de octubre de 2023

Lanzamiento de androidx.lifecycle:lifecycle-*:2.7.0-alpha03. La versión 2.7.0-alpha03 contiene estas confirmaciones.

Nuevas funciones

lifecycle-runtime-testing ahora contiene una nueva verificación de lint para evitar configurar el Lifecycle.State de TestLifecycleOwner mediante el campo currentState cuando se encuentra dentro de una corrutina. La comprobación de lint ahora sugiere la suspensión de setCurrentState, que permite configurar Lifecycle.State sin bloquearlo. (Icf728, b/297880630)

Correcciones de errores

Se solucionó un problema con LiveData.switchMap por el que mostrar la misma instancia de LiveData en la llamada inicial y en una llamada posterior impedía que la instancia de LiveData se agregara como fuente. (Ibedcba7).

Versión 2.7.0-alpha02

6 de septiembre de 2023

Lanzamiento de androidx.lifecycle:lifecycle-*:2.7.0-alpha02. La versión 2.7.0-alpha02 contiene estas confirmaciones.

Nuevas funciones

TestLifecycleOwner ahora incluye la función de suspensión setCurrentState() para darles a los usuarios la opción de usar TestLifecycleOwner desde una corrutina, como la que proporciona runTest. (I329de, b/259344129).

Cambios en la API

Todos los archivos de los módulos lifecycle-livedata-ktx se movieron al módulo lifecycle-livedata principal. (I10c6f, b/274800183).

Cambios en el comportamiento

Las extensiones LiveData.map() y LiveData.switchMap() ahora establecen el value del LiveData que se muestra si el LiveData anterior tiene un valor establecido, lo que garantiza que el uso del LiveData resultante en Jetpack Compose tenga el estado correcto en la composición inicial. (I91d2b, b/269479952).
El addCloseable() de ViewModel ahora cierra inmediatamente el Closeable si el ViewModel ya recibió una llamada a onCleared(). (I4712e, b/280294730).

Correcciones de errores

Desde Lifecycle 2.6.2: Se corrigió un problema por el que SavedStateHandle no se restablecía correctamente después del cierre del proceso si se restablecía el estado, se llamaba a save() sin guardar el estado en el SavedStateRegistry superior y, luego, se restablecía el estado nuevamente. Esto corrige la interacción entre rememberSaveable y NavHost de Navigation Compose. (aosp/2729289).

Versión 2.7.0-alpha01

26 de julio de 2023

Lanzamiento de androidx.lifecycle:lifecycle-*:2.7.0-alpha01. La versión 2.7.0-alpha01 contiene estas confirmaciones.

Cambios en la API

Lifecycle.State ahora es observable por Compose a través de Lifecycle.currentStateFlow, que muestra un StateFlow en el que value es el Lifecycle.State actual. (Ib212d, b/209684871).
Ahora, los Lifecycle.Event se pueden observar como Flow con Lifecycle.asFlow(). (If2c0f, b/176311030).
Se agregó la API de LifecycleResumeEffect para ejecutar SideEffect de Compose en función de las devoluciones de llamada de eventos Lifecycle.Event.ON_RESUME y Lifecycle.Event.ON_PAUSE. (I60386, b/235529345).
Se agregó la API de LifecycleStartEffect para ejecutar SideEffect de Compose en función de devoluciones de llamada de eventos Lifecycle.Event.ON_START y Lifecycle.Event.ON_STOP. (I5a8d1, b/235529345).
Se agregó la API de LifecycleEventEffect para ejecutar SideEffect de Compose en función de Lifecycle.Event. (Ic9794, b/235529345).
Se agregó la extensión Lifecycle.collectAsState() para exponer directamente Lifecycle.State como State de Compose. Esto equivale (y es una alternativa más corta) a lifecycle.currentStateFlow.collectAsState(). (I11015, b/235529345).

Correcciones de errores

La extensión LiveData.distinctUntilChanged() ahora establece el value del LiveData que se muestra si el LiveData anterior tiene un valor establecido. Esto no cambia el comportamiento de observación: los valores actualizados de la fuente LiveData solo se aplicarán una vez que comiences a observar el LiveData que se muestra desde distinctUntilChanged(). (Ib482f).
Se quitaron las reglas de retención de Proguard asociadas con LifecycleObserver. Esto significa que el código protegido que desee usar APIs a través de la reflexión deberá proporcionar sus propias reglas de retención para su caso de uso específico. (Ia12fd).

Versión 2.6

Versión 2.6.2

6 de septiembre de 2023

Lanzamiento de androidx.lifecycle:lifecycle-*:2.6.2. La versión 2.6.2 contiene estas confirmaciones.

Correcciones de errores

Se corrigió un problema por el que SavedStateHandle no se restablecía correctamente después del cierre del proceso si se restablecía el estado, se llamaba a save() sin guardar el estado en el SavedStateRegistry superior y, luego, se restablecía el estado nuevamente. Esto corrige la interacción entre rememberSaveable y NavHost de Navigation Compose. (aosp/2729289).

Versión 2.6.1

22 de marzo de 2023

Lanzamiento de androidx.lifecycle:lifecycle-*:2.6.1. La versión 2.6.1 contiene estas confirmaciones.

Actualizaciones de dependencias

lifecycle-viewmodel-savedstate ahora depende de SavedState 1.2.1. (cd7251)
Lifecycle ahora depende de ProfileInstaller 1.3.0. (f9d30b).

Versión 2.6.0

8 de marzo de 2023

Lanzamiento de androidx.lifecycle:lifecycle-*:2.6.0. La versión 2.6.0 contiene estas confirmaciones.

Cambios importantes desde la versión 2.5.0

LiveData ahora incluye una nueva propiedad isInitialized que indica si se configuró un valor explícito en el elemento LiveData, lo que te permite distinguir entre un liveData.value que muestra null porque nunca se estableció un valor o un valor null explícito
MediatorLiveData ahora incluye un constructor para establecer un valor inicial
Se agregó una nueva extensión en StateFlow y Flow de collectAsStateWithLifecycle() que recopila datos de flujos y representa su último valor como estado de Compose de manera optimizada para los ciclos de vida.
Los métodos Lifecycle.launchWhenX y Lifecycle.whenX dejaron de estar disponibles, ya que el uso de un despachador en pausa puede generar desperdicio de recursos en algunos casos. Se recomienda usar Lifecycle.repeatOnLifecycle Para obtener más información sobre la suspensión de trabajo por única vez, consulta esta explicación sobre por qué esto es inherentemente inseguro.
Conversión a Kotlin: Se convirtió una gran cantidad de clases de Lifecycle a Kotlin. Todas las clases convertidas conservan su compatibilidad binaria con versiones anteriores. Las siguientes clases tienen cambios incompatibles con la fuente para las clases escritas en Kotlin: ViewTreeLifecycleOwner, LiveDataReactiveStreams, HasDefaultViewModelProviderFactory, ViewTreeViewModelStoreOwner, Transformations, ViewModelStoreOwner y LifecycleOwner.

En la siguiente tabla, se proporcionan las conversiones de origen para la nueva versión del ciclo de vida.

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

La nulabilidad del método onChanged de un Observer creado en Kotlin ahora coincide con la nulabilidad del tipo genérico. Si deseas que Observer.onChanged() acepte un tipo anulable, debes crear una instancia de Observer con un tipo anulable.
Estas clases también se convirtieron a Kotlin, pero siguen siendo compatibles con la fuente: DefaultLifecycleObserver, LifecycleEventObserver, Lifecycle, LifecycleRegistry, LifecycleObserver, ViewModelStore, AndroidViewModel, AbstractSavedStateViewModelFactory, LifecycleService, ServiceLifecycleDispatcher y ProcessLifecycleOwner

Versión 2.6.0-rc01

22 de febrero de 2023

Lanzamiento de androidx.lifecycle:lifecycle-*:2.6.0-rc01. La versión 2.6.0-rc01 contiene estas confirmaciones.

Correcciones de errores

La extensión LiveData.distinctUntilChanged() ahora establece el value del LiveData que se muestra si el LiveData anterior tiene un valor establecido. Esto no cambia el comportamiento de observación: los valores actualizados de la fuente LiveData solo se aplicarán una vez que comiences a observar el LiveData que se muestra desde distinctUntilChanged(). (Ib482f).

Versión 2.6.0-beta01

8 de febrero de 2023

Lanzamiento de androidx.lifecycle:lifecycle-*:2.6.0-beta01. La versión 2.6.0-beta01 contiene estas confirmaciones.

Conversiones de Kotlin

LifecycleOwner ahora está escrito en Kotlin. Este es un cambio incompatible de la fuente para las clases escritas en Kotlin; ahora deben anular la propiedad lifecycle en lugar de implementar la función getLifecycle() anterior (I75b4b, b/240298691).
ViewModelStoreOwner ahora está disponible en Kotlin. Este es un cambio incompatible de la fuente para las clases escritas en Kotlin; ahora deben anular la propiedad viewModelStore en lugar de implementar la función getViewModelStore() anterior (I86409, b/240298691).
La extensión de Kotlin en LifecycleOwner que proporciona el campo lifecycleScope se movió al artefacto lifecycle-common desde lifecycle-runtime-ktx (I41d78, b/240298691).
La extensión de Kotlin en Lifecycle que proporciona el campo coroutineScope se movió al artefacto lifecycle-common desde lifecycle-runtime-ktx (Iabb91, b/240298691).

Versión 2.6.0-alpha05

25 de enero de 2023

Se lanzó androidx.lifecycle:lifecycle-*:2.6.0-alpha05. La versión 2.6.0-alpha05 contiene estas confirmaciones.

Conversiones de Kotlin

Transformations ahora está escrito en Kotlin. Este es un cambio incompatible de la fuente para esas clases escritas en Kotlin que usaban directamente sintaxis, como Transformations.map. El código de Kotlin ahora debe usar la sintaxis del método de extensión de Kotlin que antes solo estaba disponible cuando se usaba lifecycle-livedata-ktx. Cuando se usa el lenguaje de programación Java, las versiones de estos métodos que toman un método androidx.arch.core.util.Function dejan de estar disponibles y se reemplazan por las versiones que toman Function1 de Kotlin. Este cambio mantiene la compatibilidad binaria (I8e14f).
ViewTreeViewModelStoreOwner ahora está escrito en Kotlin. Este es un cambio incompatible de la fuente para esas clases escritas en Kotlin. Ahora, debes importar y usar directamente los métodos de extensión de Kotlin en View de androidx.lifecycle.setViewTreeViewModelStoreOwner y androidx.lifecycle.findViewTreeViewModelStoreOwner para establecer y encontrar un propietario que se haya configurado con anterioridad. Esto es compatible a nivel binario y de la fuente para implementaciones escritas en el lenguaje de programación Java (Ia06d8, Ib22d8, b/240298691).
La interfaz HasDefaultViewModelProviderFactory ahora está escrita en Kotlin. Este es un cambio incompatible de la fuente para las clases escritas en Kotlin; ahora deben anular las propiedades defaultViewModelProviderFactory y defaultViewModelCreationExtras en lugar de implementar las funciones correspondientes anteriores (Iaed9c, b/240298691).
Observer ahora está escrito en Kotlin. Su método onChanged() ahora usa el nombre value para su parámetro (Iffef2, I4995e, b/240298691).
AndroidViewModel, AbstractSavedStateViewModelFactory, LifecycleService, ServiceLifecycleDispatcher y ProcessLifecycleOwner ahora están escritos en Kotlin. (I2e771, Ibae40, I160d7, I08884, I1cda7, b/240298691).

Versión 2.6.0-alpha04

11 de enero de 2023

Lanzamiento de androidx.lifecycle:lifecycle-*:2.6.0-alpha04. La versión 2.6.0-alpha04 contiene estas confirmaciones.

Nuevas funciones

LiveData ahora incluye una nueva propiedad isInitialized que indica si se configuró un valor explícito en el elemento LiveData, lo que te permite distinguir entre un liveData.value que muestra null porque nunca se estableció un valor o un valor null explícito (Ibd018).

Cambios en la API

Las APIs de collectAsStateWithLifecycle() de lifecycle-runtime-compose ya no se encuentran en estado experimental (I09d42, b/258835424).
Los métodos Lifecycle.launchWhenX y Lifecycle.whenX dejaron de estar disponibles, ya que el uso de un despachador en pausa puede generar desperdicio de recursos en algunos casos. Se recomienda usar Lifecycle.repeatOnLifecycle (Iafc54, b/248302832).

Conversiones de Kotlin

ViewTreeLifecycleOwner ahora está escrito en Kotlin. Este es un cambio incompatible de la fuente para esas clases escritas en Kotlin. Ahora debes importar y usar directamente los métodos de extensión de Kotlin en View de androidx.lifecycle.setViewTreeLifecycleOwner y androidx.lifecycle.findViewTreeLifecycleOwner para establecer y encontrar un propietario que se haya configurado con anterioridad. Esto reemplaza la extensión de Kotlin anterior en lifecycle-runtime-ktx. Esto es compatible a nivel binario y de la fuente para implementaciones escritas en el lenguaje de programación Java (I8a77a, I5234e, b/240298691).
LiveDataReactiveStreams ahora está escrito en Kotlin. Las extensiones de Kotlin que se encontraban en lifecycle-reactivestreams-ktx se trasladaron al módulo lifecycle-reactivestreams y se convirtieron en la plataforma principal del código escrito en Kotlin. Este es un cambio incompatible de la fuente para el código escrito en Kotlin si no usabas las APIs del método de extensión de Kotlin (I2b1b9, I95d22, b/240298691).
DefaultLifecycleObserver, LifecycleEventObserver, Lifecycle, LifecycleRegistry, LifecycleObserver y ViewModelStore ahora están escritos en Kotlin (Iadffd, I60034, I8c52c, I9593d, I01fe1, I59a23, b/240298691).

Correcciones de errores

SavedStateHandle ya no falla con una ClassCastException cuando se llama a get() con el tipo de clase incorrecto (I6ae7c).

Versión 2.6.0-alpha03

24 de octubre de 2022

Lanzamiento de androidx.lifecycle:lifecycle-*:2.6.0-alpha03. La versión 2.6.0-alpha03 contiene estas confirmaciones.

Correcciones de errores

Se solucionó un problema con restricciones entre diferentes módulos de Lifecycle que no funcionaban correctamente (I18d0d, b/249686765).
Los errores arrojados por LifecycleRegistry.moveToState() ahora incluyen un mensaje de error más útil que informa a los desarrolladores sobre el componente que causa el error (Idf4b2, b/244910446).

Versión 2.6.0-alpha02

7 de septiembre de 2022

Se lanzó androidx.lifecycle:lifecycle-*:2.6.0-alpha02. La versión 2.6.0-alpha02 contiene estas confirmaciones.

Cambios en la API

MediatorLiveData ahora incluye un constructor para establecer un valor inicial (Ib6cc5 y b/151244085).

Correcciones de errores

Los artefactos Lifecycle ahora incluyen restricciones que garantizan que todos los artefactos de Lifecycle interdependientes usen la misma versión y actualicen automáticamente otras dependencias cuando se actualice una (b/242871265).
FlowLiveData.asFlow() ahora crea un callbackFlow en lugar de usar su propia implementación de Channel para garantizar la seguridad del subproceso y la preservación del contexto (I4a8b2 y b/200596935).
La función asLiveData de FlowLiveData ahora conservará el valor inicial de un StateFlow cuando se cree el nuevo objeto LiveData (I3f530 y b/157380488)
A partir de Lifecycle 2.5.1: Las implementaciones personalizadas deAndroidViewModelFactory ahora llaman correctamente a la función create(modelClass) cuando se usa el constructor con estado con Lifecycle 2.4+ (I5b315 y b/238011621).

Versión 2.6.0-alpha01

29 de junio de 2022

Se lanzó androidx.lifecycle:lifecycle-*:2.6.0-alpha01. La versión 2.6.0-alpha01 contiene estas confirmaciones.

Nuevas funciones

Se agregó una nueva extensión en StateFlow y Flow de collectAsStateWithLifecycle, que recopila datos de flujos y representa su último valor como estado de Compose de manera optimizada para los ciclos de vida. El flujo se recopila y la nueva emisión se establece en el valor del estado cuando el ciclo de vida se encuentra, al menos, en un Lifecycle.State determinado. Cuando el ciclo de vida es inferior a ese Lifecycle.State, la recopilación de flujos se detiene y el valor del estado no se actualiza (I1856e, b/230557927).

Versión 2.5

Versión 2.5.1

27 de julio de 2022

Lanzamiento de androidx.lifecycle:lifecycle-*:2.5.1. La versión 2.5.1 contiene estas confirmaciones.

Correcciones de errores

Las implementaciones personalizadas de AndroidViewModelFactory ahora llaman correctamente a la función create(modelClass) cuando se usa el constructor con estado AndroidViewModelFactory con Lifecycle 2.4+ (I5b315, b/238011621).

Versión 2.5.0

29 de junio de 2022

Se lanzó androidx.lifecycle:lifecycle-*:2.5.0. La versión 2.5.0 contiene estas confirmaciones.

Cambios importantes desde 2.4.0

SavedStateHandle ahora ofrece una API de getStateFlow() que muestra un elemento Kotlin StateFlow para supervisar los cambios de valores como alternativa al uso de LiveData.

ViewModel CreationExtras: cuando escribes un ViewModelProvider.Factory personalizado, ya no es necesario extender AndroidViewModelFactory o AbstractSavedStateViewModelFactory para obtener acceso a Application o SavedStateHandle, respectivamente. En cambio, estos campos se proporcionan a todas las subclases de ViewModelProvider.Factory como CreationExtras mediante la nueva sobrecarga de create: create(Class<T>, CreationExtras). Tu actividad o fragmento proporcionan automáticamente estos extras cuando usan Activity 1.5.0 y Fragment 1.5.0, respectivamente.

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 ahora proporciona un viewModelFactory de DSL de Kotlin que te permite definir tu ViewModelProvider.Factory en términos de uno o más inicializadores de lambda, uno para cada clase de ViewModel en particular que admita tu fábrica personalizada, mediante CreationExtras como la principal fuente de datos.

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 ahora ofrece una API de viewModel() que toma una fábrica de expresiones lambda para crear una instancia ViewModel sin necesidad de crear una ViewModelProvider.Factory personalizada.

// 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)
}

Integración de ahorro de SavedStateHandle: El artefacto lifecycle-viewmodel-compose ahora incluye nuevas APIs experimentales en SavedStateHandle.saveable que permiten el comportamiento rememberSaveable respaldado por el SavedStateHandle de 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) }
}
```

Se agregó una API de addCloseable() y una nueva sobrecarga de constructor que te permiten agregar uno o más objetos Closeable a ViewModel, que se cerrará cuando ViewModel se borra sin requerir trabajo manual en onCleared().

Por ejemplo, para crear un alcance de corrutina que puedas insertar en un ViewModel, pero controlar mediante pruebas, puedes crear un CoroutineScope que implemente Closeable:

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

Se puede usar en el constructor ViewModel mientras se mantiene la misma duración que viewModelScope:

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

Cambios en el comportamiento

Si intentas mover Lifecycle.State de INITIALIZED a DESTROYED, ahora siempre se mostrará una IllegalStateException, independientemente de que Lifecycle tenga un observador adjunto.
LifecycleRegistry ahora borrará a sus observadores cuando alcancen el estado DESTROYED.

Versión 2.5.0-rc02

15 de junio de 2022

Se lanzó androidx.lifecycle:lifecycle-*:2.5.0-rc02. La versión 2.5.0-rc02 contiene estas confirmaciones.

Correcciones de errores

ViewModelProvider ya no fallará cuando se combinen versiones anteriores de dependencias de compileOnly Lifecycle con versiones de 2.5 y posteriores (I81a66, b/230454566).

Versión 2.5.0-rc01

11 de mayo de 2022

Se lanzó androidx.lifecycle:lifecycle-*:2.5.0-rc01. La versión 2.5.0-rc01 contiene estas confirmaciones.

Correcciones de errores

MediatorLiveData.addSource() ahora arroja una NullPointerException cuando se pasa una null fuente, en lugar de propagar null fuente a los observadores (Ibd0fb, b/123085232).

Versión 2.5.0-beta01

20 de abril de 2022

Se lanzó androidx.lifecycle:lifecycle-*:2.5.0-beta01. La versión 2.5.0-beta01 contiene estas confirmaciones.

Cambios en la API

Se agregaron los delegados de propiedad SavedStateHandle.saveable para usar nombres de propiedad como claves para el estado persistente en SavedStateHandle (I8bb86, b/225014345).

Correcciones de errores

Se solucionó un problema por el que, si se anidaba un NavHost dentro de otro NavHost en una pestaña de navegación inferior que no era la principal, se generaba un IllegalStateException cuando se usaban varias pilas de actividades (I11bd5, b/228865698).

Versión 2.5.0-alpha06

6 de abril de 2022

Lanzamiento de androidx.lifecycle:lifecycle-*:2.5.0-alpha06. La versión 2.5.0-alpha06 contiene estas confirmaciones.

Nuevas funciones

Se agregó una sobrecarga experimental de MutableState a SavedStateHandle.saveable para obtener paridad con rememberSaveable (I38cfe, b/224565154).

Cambios en la API

CreationExtras ahora es abstracto en lugar de sellado (Ib8a7a).

Correcciones de errores

Se corrigió un error IllegalStateException: Already attached to lifecycleOwner causado por SavedStateHandleController (I7ea47, b/215406268).

Versión 2.5.0-alpha05

23 de marzo de 2022

Lanzamiento de androidx.lifecycle:lifecycle-*:2.5.0-alpha05. La versión 2.5.0-alpha05 contiene estas confirmaciones.

Nuevas funciones

El módulo lifecycle-viewmodel-compose ahora proporciona SavedStateHandleSaver, una API experimental que garantiza que los valores en un SavedStateHandle se integren de forma correcta con el mismo estado de instancia guardado que usa rememberSaveable (Ia88b7, b/195689777).

Cambios en la API

Se solucionó un problema de compatibilidad con Lifecycle 2.3 y versiones posteriores de Lifecycle en Java (I52c8a, b/219545060).

Correcciones de errores

SavedStateViewFactory ahora admite el uso de CreationExtras, incluso cuando se inicializó con un SavedStateRegistryOwner. Si se proporcionan elementos adicionales, se ignoran los argumentos inicializados (I6c43b, b/224844583).

Versión 2.5.0-alpha04

9 de marzo de 2022

Lanzamiento de androidx.lifecycle:lifecycle-*:2.5.0-alpha04. La versión 2.5.0-alpha04 contiene estas confirmaciones.

Cambios en la API

SavedStateHandle ahora ofrece una API de getStateFlow() que muestra un elemento Kotlin StateFlow para supervisar los cambios de valores como alternativa al uso de LiveData (Iad3ab, b/178037961).

Versión 2.5.0-alpha03

23 de febrero de 2022

Lanzamiento de androidx.lifecycle:lifecycle-*:2.5.0-alpha03. La versión 2.5.0-alpha03 contiene estas confirmaciones.

Nuevas funciones

Se agregó una API de addCloseable() y una nueva sobrecarga de constructor que te permiten agregar uno o más objetos Closeable a ViewModel, que se cerrará cuando ViewModel se borra sin requerir trabajo manual en onCleared() (I55ea0).
lifecycle-viewmodel ahora proporciona un InitializerViewModelFactory que te permite agregar lambda para controlar clases ViewModel particulares, usando CreationExtras como la fuente de datos principal (If58fc, b/216687549).
lifecycle-viewmodel-compose ahora ofrece una API de viewModel() que toma una fábrica de expresiones lambda para crear una instancia ViewModel sin necesidad de crear una ViewModelProvider.Factory personalizada (I97fbb, b/216688927).

Cambios en la API

Ahora puedes crear un ViewModel con CreationExtras a través de lifecycle-viewmodel-compose (I08887, b/216688927).

Cambios en el comportamiento

Si intentas mover Lifecycle.State de INITIALIZED a DESTROYED, ahora siempre se mostrará una IllegalStateException, independientemente de que Lifecycle tenga un observador adjunto (I7c390, b/177924329).
LifecycleRegistry ahora borrará a sus observadores cuando alcancen el estado DESTROYED (I4f8dd, b/142925860).

Versión 2.5.0-alpha02

9 de febrero de 2022

Lanzamiento de androidx.lifecycle:lifecycle-*:2.5.0-alpha02. La versión 2.5.0-alpha02 contiene estas confirmaciones.

Cambios en la API

SavedStateHandle y SavedStateViewModelFactory se convirtieron a Kotlin. Esto mejoró la nulabilidad de los elementos genéricos en ambas clases (Ib6ce2, b/216168263, I9647a, b/177667711).
El parámetro de la función switchMap de LiveData ahora puede tener un resultado anulable (I40396, b/132923666).
Las extensiones -ktx de LiveData ahora tienen anotaciones con @CheckResult para garantizar que el resultado se use cuando se llama a estas funciones (Ia0f05, b/207325134).

Cambios en el comportamiento

SavedStateHandle ahora almacena correctamente el defaultValue cuando no existe un valor para la clave especificada (I1c6ce, b/178510877).

Correcciones de errores

A partir de Lifecycle 2.4.1: Se actualizó lifecycle-process para que dependa de Startup 1.1.1 a fin de garantizar que las correcciones que evitan que ProcessLifecycleInitializer arroje una StartupException estén disponibles de forma predeterminada (Ib01df, b/216490724).
Ahora se muestra un mensaje de error mejorado cuando las clases AndroidViewModel personalizadas tienen parámetros en el orden incorrecto y tratan de crear un ViewModel (I340f7, b/177667711).
Ahora puedes crear un modelo de vista con CreationExtras si usas AndroidViewModelFactory sin configurar una aplicación (I6ebef, b/217271656).

Versión 2.5.0-alpha01

26 de enero de 2022

Lanzamiento de androidx.lifecycle:lifecycle-*:2.5.0-alpha01. La versión 2.5.0-alpha01 contiene estas confirmaciones.

CreationExtras de ViewModel

En esta versión, sentamos las bases para la reestructuración de la construcción de ViewModel. En lugar de un conjunto rígido de subclases de ViewModelProvider.Factory que agregan, de forma individual, funcionalidades adicionales (se permite un parámetro de constructor Application mediante AndroidViewModelFactory, lo que permite un parámetro de constructor SavedStateHandle a través de SavedStateViewModelFactory y AbstractSavedStateViewModelFactory, etc.), estamos migrando a un mundo de fábricas sin estado que se basan en un nuevo concepto, CreationExtras (Ia7343, b/188691010, b/188541057).

Con este cambio, ViewModelProvider ya no realiza llamadas directas al método create(Class<T>) anterior de ViewModelProvider.Factory. En cambio, llama a una nueva sobrecarga de create: create(Class<T>, CreationExtras). Esto significa que cualquier implementación directa de la instancia de ViewModelProvider.Factory ahora tiene acceso a cada una de estas instancias de CreationExtras nuevas:

ViewModelProvider.NewInstanceFactory.VIEW_MODEL_KEY: Esta String proporciona acceso a la clave personalizada que pasaste a ViewModelProvider.get().
ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY proporciona acceso a la clase Application.
SavedStateHandleSupport.SAVED_STATE_REGISTRY_OWNER_KEY proporciona acceso a SavedStateRegistryOwner que se usa para construir este ViewModel.
SavedStateHandleSupport.VIEW_MODEL_STORE_OWNER_KEY proporciona acceso a ViewModelStoreOwner que se usa para construir este ViewModel.
SavedStateHandleSupport.DEFAULT_ARGS_KEY proporciona acceso al Bundle de los argumentos que se deben usar para construir un elemento SavedStateHandle.

Estos elementos adicionales se proporcionan de forma predeterminada cuando se usan los objetos Activity 1.5.0-alpha01, Fragment 1.5.0-alpha01 y Navigation 2.5.0-alpha01. Si usas una versión anterior de esas bibliotecas, tus CreationExtras estarán vacíos. Se reescribieron todas las subclases existentes de ViewModelProvider.Factory para admitir la ruta de creación heredada que usaban las versiones anteriores de esas bibliotecas y la ruta de CreationExtras que se utilizará en el futuro.

Estos CreationExtras te permiten construir un elemento ViewModelProvider.Factory que pasa solo la información que necesitas a cada ViewModel sin depender de una jerarquía estricta de subclases Factory:

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

Usamos la función de extensión de Kotlin createSavedStateHandle() en CreationExtras desde SavedStateHandleSupport para construir un elemento SavedStateHandle solo para el ViewModel que lo necesita (Ia6654, b/188541057).

Se pueden proporcionar CreationExtras personalizados si se anulan getDefaultViewModelCreationExtras() en tu ComponentActivity o Fragment, de modo que estén disponibles para tu ViewModelProvider.Factory personalizado como una forma de inyección asistida. Estos elementos adicionales estarán disponibles de forma automática para tu Factory personalizada cuando se usen directamente con ViewModelProvider o cuando se usen las extensiones de propiedad de Kotlin by viewModels() y by activityViewModels() (I79f2b, b/207012584, b/207012585 y b/207012490).

Correcciones de errores

Se corrigió un problema en el que el valor predeterminado proporcionado a un SavedStateHandle volvía a aparecer después del cierre del proceso y de su recreación, incluso si se quitaba específicamente de SavedStateHandle. Como consecuencia de esto, SavedStateHandle ya no fusionará los valores predeterminados y los valores restablecidos, sino que solo usará los valores restablecidos como fuente de información (I53a4b).

Versión 2.4

Versión 2.4.1

9 de febrero de 2022

Lanzamiento de androidx.lifecycle:lifecycle-*:2.4.1. La versión 2.4.1 contiene estas confirmaciones.

Correcciones de errores

Portabilidad a versiones anteriores de Lifecycle 2.5.0-alpha01: Se corrigió un problema por el que el valor predeterminado proporcionado a un SavedStateHandle volvía a aparecer después del cierre del proceso y de su recreación, incluso si se quitaba específicamente de SavedStateHandle. Como consecuencia de esto, SavedStateHandle ya no fusionará los valores predeterminados y los valores restablecidos, sino que solo usará los valores restablecidos como fuente de información (I53a4b).
lifecycle-process ahora depende de Androidx Startup 1.1.1, que corrigió una regresión en la que el uso de ProcessLifecycleInitializer generaba una StartupException (b/216490724).

Versión 2.4.0

27 de octubre de 2021

Lanzamiento de androidx.lifecycle:lifecycle-*:2.4.0. La versión 2.4.0 contiene estas confirmaciones.

Cambios importantes desde la versión 2.3.0

El objeto @OnLifecycleEvent dejó de estar disponible. En su lugar, se debe usar LifecycleEventObserver o DefaultLifecycleObserver.
Se agregó la biblioteca androidx.lifecycle:lifecycle-viewmodel-compose. Brinda el elemento viewModel() componible y LocalViewModelStoreOwner.
- Cambio rotundo en el código fuente: Se reescribió ViewModelProvider en Kotlin. El método ViewModelProvider.Factory.create ya no permite elementos genéricos anulables.
Se agregó una nueva API de corrutinas a androidx.lifecycle:lifecycle-runtime-ktx:
Lifecycle.repeatOnLifecycle: Es una API que ejecuta un bloque de código en una corrutina cuando el ciclo de vida se encuentra, al menos, en un estado determinado. El bloque se cancelará y se volverá a iniciar a medida que el ciclo de vida entre al estado de destino y salga de él.
Flow.flowWithLifecycle: Es una API que emite valores del flujo ascendente cuando el ciclo de vida se encuentra en, al menos, un estado determinado.
DefaultLifecycleObserver se trasladó de lifecycle.lifecycle-common-java8 a lifecycle.lifecycle-common. lifecycle.lifecycle-common-java8 ya no proporciona ninguna funcionalidad adicional además de lifecycle.lifecycle-common, por lo que se puede reemplazar la dependencia por lifecycle.lifecycle-common.
Se trasladó la API de corrutinas de lifecycle-viewmodel-ktx al módulo lifecycle-viewmodel.

lifecycle-process ahora usa androidx.startup para inicializar ProcessLifecycleOwner.

Anteriormente, lo hacía androidx.lifecycle.ProcessLifecycleOwnerInitializer.

Si usaste tools:node="remove", el elemento ContentProvider que se usaba en el pasado para inicializar el proceso de ciclo de vida, debes hacer lo siguiente:

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

(O)

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

Versión 2.4.0-rc01

29 de septiembre de 2021

Se lanzó androidx.lifecycle:lifecycle-*:2.4.0-rc01 sin modificaciones desde Lifecycle 2.4.0-beta01. La versión 2.4.0-rc01 contiene estas confirmaciones.

Versión 2.4.0-beta01

15 de septiembre de 2021

Lanzamiento de androidx.lifecycle:lifecycle-*:2.4.0-beta01. La versión 2.4.0-beta01 contiene estas confirmaciones.

Cambios en la API

El objeto @OnLifecycleEvent dejó de estar disponible. En su lugar, se debe usar LifecycleEventObserver o DefaultLifecycleObserver. (I5a8fa)
Se movió DefaultLifecycleObserver de androidx.lifecycle.lifecycle-common-java8 a androidx.lifecycle.lifecycle-common. androidx.lifecycle.lifecycle-common-java8 ya no proporciona ninguna funcionalidad adicional además de androidx.lifecycle.lifecycle-common, por lo que se puede reemplazar la dependencia por androidx.lifecycle.lifecycle-common. (I021aa)
Se trasladó la API de corrutinas de lifecycle-viewmodel-ktx al módulo lifecycle-viewmodel. (I6d5b2)

Contribución externa

Agradecemos a dmitrilc por corregir un error tipográfico en la documentación de ViewModel. (#221)

Versión 2.4.0-alpha03

4 de agosto de 2021

Lanzamiento de androidx.lifecycle:lifecycle-*:2.4.0-alpha03. La versión 2.4.0-alpha03 contiene estas confirmaciones.

Cambios en la API

Cambio rotundo en el código fuente: Se reescribió ViewModelProvider en Kotlin. El método ViewModelProvider.Factory.create ya no permite elementos genéricos anulables (I9b9f6).

Cambios en el comportamiento

Lifecycle.repeatOnLifecycle: block ahora se invoca siempre en serie cuando se repite la ejecución. (Ibab33)

Contribución externa

Gracias a chao2zhang por corregir los fragmentos de código en la documentación de repeatOnLifecycle. #205.

Versión 2.4.0-alpha02

16 de junio de 2021

Lanzamiento de androidx.lifecycle:lifecycle-*:2.4.0-alpha02. La versión 2.4.0-alpha02 contiene estas confirmaciones.

Nuevas funciones

Se agregó una nueva verificación de lint RepeatOnLifecycleWrongUsage a lifecycle-runtime-ktx que detecta cuando repeateOnLifecycle se usa incorrectamente en onStart() o onResume(). (706078, b/187887400)

Cambios en la API

Se quitó la API LifecycleOwner.addRepeatingJob para fomentar el uso de Lifecycle.repeatOnLifecycle, que respeta la simultaneidad estructurada y es más fácil de entender. (I4a3a8)
ProcessLifecycleInitializer ahora es público para que otros androidx.startup.Initializer puedan usarlo como dependencia. (I94c31)

Correcciones de errores

Se corrigió un problema con la verificación de lint NullSafeMutableLiveData por el que el campo tenía modificadores. (#147, b/183696616)
Se corrigió otro error relacionado con la verificación de lint NullSafeMutableLiveData por el que se usaban elementos genéricos. (#161, b/184830263)

Contribución externa

Gracias maxsvv por mejorar la verificación de lint NullSafeMutableLiveData. (#147, b/183696616)
Gracias kozaxiina por mejorar la verificación de lint NullSafeMutableLiveData. (#161, b/184830263)

Versión 2.4.0-alpha01

24 de marzo de 2021

Lanzamiento de androidx.lifecycle:lifecycle-*:2.4.0-alpha01. La versión 2.4.0-alpha01 contiene estas confirmaciones.

Cambios en el comportamiento

lifecycle-process ahora usa androidx.startup para inicializar ProcessLifecycleOwner.

Anteriormente, lo hacía androidx.lifecycle.ProcessLifecycleOwnerInitializer.

Si usaste tools:node="remove", el elemento ContentProvider que se usaba en el pasado para inicializar el proceso de ciclo de vida, debes hacer lo siguiente:

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

(O)

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

Cambios en la API

Se agregó una API de Flow.flowWithLifecycle que emite valores del flujo ascendente cuando el ciclo de vida se encuentra en, al menos, un estado determinado usando la API de Lifecycle.repeatOnLifecycle. Esta es una alternativa a la nueva API de LifecycleOwner.addRepeatinJob. (I0f4cd)

Correcciones de errores

A partir del Lifecycle versión 2.3.1: La regla de lint de NonNullableMutableLiveData ahora puede diferenciar correctamente entre las variables de campo y las diferentes nulabilidades. (b/169249668)

Lifecycle Viewmodel Compose versión 1.0.0

Versión 1.0.0-alpha07

16 de junio de 2021

Lanzamiento de androidx.lifecycle:lifecycle-viewmodel-compose:1.0.0-alpha07. La versión 1.0.0-alpha07 contiene estas confirmaciones.

Cambios rotundos en la API

Ahora viewModel() toma un ViewModelStoreOwner opcional, lo que facilita el trabajo con propietarios que no sean LocalViewModelStoreOwner. Por ejemplo, ahora puedes usar viewModel(navBackStackEntry) para recuperar un ViewModel asociado con un gráfico de navegación en particular (I2628d, b/188693123)

Versión 1.0.0-alpha06

2 de junio de 2021

Lanzamiento de androidx.lifecycle:lifecycle-viewmodel-compose:1.0.0-alpha06. La versión 1.0.0-alpha06 contiene estas confirmaciones.

Se actualizó para ser compatible con la versión 1.0.0-beta08 de Compose.

Versión 1.0.0-alpha05

18 de mayo de 2021

Lanzamiento de androidx.lifecycle:lifecycle-viewmodel-compose:1.0.0-alpha05. La versión 1.0.0-alpha05 contiene estas confirmaciones.

Nuevas funciones

Se actualizó para que sea compatible con la versión 1.0.0-beta07 de Compose.

Correcciones de errores

Los archivos AndroidManifest de ui-test-manifest y ui-tooling-data ahora son compatibles con Android 12 (I6f9de, b/184718994).

Versión 1.0.0-alpha04

7 de abril de 2021

Lanzamiento de androidx.lifecycle:lifecycle-viewmodel-compose:1.0.0-alpha04. La versión 1.0.0-alpha04 contiene estas confirmaciones.

Cambios de dependencia

Esta versión permite que androidx.hilt:hilt-navigation-compose y androidx.navigation:navigation-compose sincronicen las dependencias en androidx.compose.compiler:compiler:1.0.0-beta04 y androidx.compose.runtime:runtime:1.0.0-beta04. Se requiere que coincidan el compilador y el tiempo de ejecución para 1.0.0.

Versión 1.0.0-alpha03

10 de marzo de 2021

Lanzamiento de androidx.lifecycle:lifecycle-viewmodel-compose:1.0.0-alpha03. La versión 1.0.0-alpha03 contiene estas confirmaciones.

Cambios en la API

LocalViewModelStoreOwner.current ahora muestra un objeto ViewModelStoreOwner anulable para determinar mejor si un ViewModelStoreOwner está disponible en la composición actual. Las API que requieren un ViewModelStoreOwner, como viewModel() y NavHost, aún generan una excepción si no se establece un ViewModelStoreOwner. (Idf39a)

Lifecycle-Viewmodel-Compose versión 1.0.0-alpha02

24 de febrero de 2021

Lanzamiento de androidx.lifecycle:lifecycle-viewmodel-compose:1.0.0-alpha02. La versión 1.0.0-alpha02 contiene estas confirmaciones.

Cambios en la API

LocalViewModelStoreOwner ahora tiene una función provides que se puede usar con CompositionLocalProvider y reemplaza la API asProvidableCompositionLocal(). (I45d24)

Lifecycle-Viewmodel-Compose versión 1.0.0-alpha01

10 de febrero de 2021

Lanzamiento de androidx.lifecycle:lifecycle-viewmodel-compose:1.0.0-alpha01. La versión 1.0.0-alpha01 contiene estas confirmaciones.

Nuevas funciones

El elemento componible viewModel() y LocalViewModelStoreOwner se movieron de androidx.compose.ui.viewinterop a este artefacto en el paquete androidx.lifecycle.viewmodel.compose (I7a374)

Versión 2.3.1

Lifecycle versión 2.3.1

24 de marzo de 2021

Lanzamiento de androidx.lifecycle:lifecycle-*:2.3.1. La versión 2.3.1 contiene estas confirmaciones.

Correcciones de errores

La regla de lint de NonNullableMutableLiveData ahora puede diferenciar correctamente entre las variables de campo y las diferentes nulabilidades. (b/169249668)

Versión 2.3.0

10 de febrero de 2021

Lanzamiento de androidx.lifecycle:lifecycle-*:2.3.0. La versión 2.3.0 contiene estas confirmaciones.

Cambios importantes desde la versión 2.2.0

Compatibilidad de SavedStateHandle para clases no parcelables: SavedStateHandle ahora admite la serialización diferida, ya que te permite llamar a setSavedStateProvider() para una clave determinada, lo que proporciona un SavedStateProvider que devolverá la llamada a saveState() cuando se le solicite a SavedStateHandle guardar su estado. Consulta Cómo guardar clases no parcelables.
Aplicación del comportamiento de Lifecycle:
- El elemento LifecycleRegistry ahora aplica el objeto DESTROYED como un estado terminal.
- El objeto LifecycleRegistry ahora verifica que se llame a sus métodos en el subproceso principal. Siempre fue un requisito para los ciclos de vida de las actividades, los fragmentos, etc. Agregar observadores de subprocesos que no eran principales generaba dificultades al momento de detectar fallas durante el tiempo de ejecución. En el caso de los objetos LifecycleRegistry que pertenecen a tus propios componentes, puedes optar por no participar explícitamente de las comprobaciones mediante el elemento LifecycleRegistry.createUnsafe(...), pero debes asegurarte de que exista una sincronización apropiada cuando se acceda a este objeto LifecycleRegistry desde diferentes subprocesos.
Ayudantes State y Event de Lifecycle: Se agregaron métodos auxiliares estáticos de downFrom(State), downTo(State), upFrom(State) y upTo(State) al objeto Lifecycle.Event para generar el elemento Event en función del parámetro State y una dirección de transición. Se agregó el método getTargetState() que proporciona el elemento State al que el objeto Lifecycle pasará directamente después del parámetro Event.
withStateAtLeast: Se agregaron las API de Lifecycle.withStateAtLeast que esperan un estado de ciclo de vida y ejecutan un bloque de código sin suspensión de forma síncrona en el punto de cambio de estado, y se reanudan con el resultado. Esas API difieren de los métodos when* existentes, ya que no permiten ejecutar el código de suspensión ni emplean un despachador personalizado. (aosp/1326081)
API de ViewTree: Una nueva API de ViewTreeLifecycleOwner.get(View) y ViewTreeViewModelStoreOwner.get(View) te permite recuperar el LifecycleOwner contenedor y ViewModelStoreOwner, respectivamente, en una determinada instancia de View. Debes actualizar a Activity 1.2.0 y Fragment 1.3.0, y a AppCompat 1.3.0-alpha01 o versiones posteriores para que se realice correctamente la propagación. Las extensiones de Kotlin findViewTreeLifecycleOwner y findViewTreeViewModelStoreOwner están disponibles en lifecycle-runtime-ktx y lifecycle-viewmodel-ktx, respectivamente.
Baja de la extensión LiveData.observe() de Kotlin: La extensión LiveData.observe() de Kotlin necesaria para usar la sintaxis lambda dejó de estar disponible, ya que no es necesaria cuando se usa Kotlin 1.4.

Versión 2.3.0-rc01

16 de diciembre de 2020

Lanzamiento de androidx.lifecycle:lifecycle-*:2.3.0-rc01. La versión 2.3.0-rc01 contiene estas confirmaciones.

Correcciones de errores

El método keys() de SavedStateHandle ahora es coherente antes y después de que se guarda el estado. También incluye las claves usadas anteriormente con setSavedStateProvider(), además de las claves que se usan con set() y getLiveData(). (aosp/1517919, b/174713653)

Contribución externa

Las API para suspender las corrutinas optimizadas para Lifecycle ahora administran mejor las llamadas a yield(). Gracias, Nicklas Ansman Giertz. (aosp/1430830, b/168777346)

Versión 2.3.0-beta01

1 de octubre de 2020

Lanzamiento de androidx.lifecycle:lifecycle-*:2.3.0-beta01. La versión 2.3.0-beta01 contiene estas confirmaciones.

Cambios en la API

La extensión LiveData.observe() de Kotlin necesaria para usar la sintaxis lambda dejó de estar disponible, ya que no es necesaria cuando se usa Kotlin 1.4. (I40d3f)

Correcciones de errores

Actualiza AndroidX para usar Kotlin 1.4 (Id6471, b/165307851, b/165300826)

Cambios en la documentación

Se actualizaron el compilador liveData y los documentos asLiveData() para incluir detalles sobre el cambio de los valores de tiempo de espera proporcionados. (aosp/1122324)

Versión 2.3.0-alpha07

19 de agosto de 2020

Lanzamiento de androidx.lifecycle:lifecycle-*:2.3.0-alpha07. La versión 2.3.0-alpha07 contiene estas confirmaciones.

Correcciones de errores

Se corrigió una falla en la comprobación de lint NullSafeMutableLiveData. (aosp/1395367)

Versión 2.3.0-alpha06

22 de julio de 2020

Lanzamiento de androidx.lifecycle:lifecycle-*:2.3.0-alpha06. La versión 2.3.0-alpha06 contiene estas confirmaciones.

Nuevas funciones

Se agregaron métodos auxiliares estáticos de downFrom(State), downTo(State), upFrom(State), upTo(State) al objeto Lifecycle.Event para generar el elemento Event en función del parámetro State y una dirección de transición. Se agregó el método getTargetState() que proporciona el elemento State al que el objeto Lifecycle pasará directamente después del parámetro Event. (I00887)
Se agregaron las API de Lifecycle.withStateAtLeast que esperan un estado de ciclo de vida y ejecutan un bloque de código sin suspensión de forma síncrona en el punto de cambio de estado, y se reanudan con el resultado. Estas API difieren de los métodos when* existentes, ya que no permiten ejecutar el código de suspensión ni emplean un despachador personalizado. (aosp/1326081)

Cambios en el comportamiento

El elemento LifecycleRegistry ahora aplica el objeto DESTROYED como un estado terminal. (I00887)
El objeto LifecycleRegistry ahora verifica que se llame a sus métodos en el subproceso principal. Siempre fue un requisito para los ciclos de vida de las actividades, los fragmentos, etc. Agregar observadores de subprocesos que no eran principales generaba dificultades al momento de detectar fallas durante el tiempo de ejecución. En el caso de los objetos LifecycleRegistry que pertenecen a tus propios componentes, puedes optar por no participar explícitamente de las comprobaciones mediante el elemento LifecycleRegistry.createUnsafe(...), pero debes asegurarte de que exista una sincronización apropiada cuando se acceda a este objeto LifecycleRegistry desde diferentes subprocesos. (Ie7280, b/137392809)

Correcciones de errores

Se corrigió una falla en NullSafeMutableLiveData. (b/159987480)
Se corrigió un objeto ObsoleteLintCustomCheck para las comprobaciones de Lint agrupadas con el elemento lifecycle-livedata-core-ktx (y, específicamente, el objeto NullSafeMutableLiveData). (b/158699265)

Versión 2.3.0-alpha05

24 de junio de 2020

Lanzamiento de androidx.lifecycle:lifecycle-*:2.3.0-alpha05. La versión 2.3.0-alpha05 contiene estas confirmaciones.

Correcciones de errores

LiveData ahora controla mejor los casos de reentrantes y evita las llamadas duplicadas a onActive() o onInactive(). (b/157840298)
Se solucionó un problema en el que las verificaciones de Lint no se ejecutaban en Android Studio 4.1 Canary 6 o versiones posteriores. (aosp/1331903)

Versión 2.3.0-alpha04

10 de junio de 2020

Lanzamiento de androidx.lifecycle:lifecycle-*:2.3.0-alpha04. La versión 2.3.0-alpha04 contiene estas confirmaciones.

Correcciones de errores

Se corrigió una falla en la comprobación de lint NonNullableMutableLiveData. (b/157294666)
La comprobación de lint NonNullableMutableLiveData ahora abarca muchos más casos en los que se estableció un valor null en un MutableLiveData con un parámetro de tipo no nulo. (b/156002218)

Versión 2.3.0-alpha03

20 de mayo de 2020

Lanzamiento de androidx.lifecycle:lifecycle-*:2.3.0-alpha03. La versión 2.3.0-alpha03 contiene estas confirmaciones.

Nuevas funciones

SavedStateHandle ahora admite la serialización diferida, ya que te permite llamar a setSavedStateProvider() para una clave determinada, lo que proporciona un SavedStateProvider que devolverá la llamada a saveState() cuando se le solicite a SavedStateHandle guardar su estado. (b/155106862)
Una nueva API de ViewTreeViewModelStoreOwner.get(View) te permite recuperar el ViewModelStoreOwner contenedor dado que tiene una instancia de View. Debes actualizar a Activity 1.2.0-alpha05, Fragment 1.3.0-alpha05 y AppCompat 1.3.0-alpha01 para completarlo correctamente. Se agregó una extensión findViewModelStoreOwner() de Kotlin a lifecycle-viewmodel-ktx. (aosp/1295522)

Correcciones de errores

Se corrigió un problema que impedía publicar las comprobaciones de lint MutableLiveData lanzadas en Lifecycle 2.3.0-alpha01 junto con el artefacto lifecycle-livedata-core-ktx. (b/155323109)

Versión 2.3.0-alpha02

29 de abril de 2020

Lanzamiento de androidx.lifecycle:lifecycle-*:2.3.0-alpha02. La versión 2.3.0-alpha02 contiene estas confirmaciones.

Cambios en la API

SavedStateViewModelFactory ahora te permite pasar un Application nulo a su constructor para mejorar los casos en los que uno no está disponible y no se necesita compatibilidad con AndroidViewModel. (aosp/1285740)

Correcciones de errores

Se mejoró el rendimiento de inicio en frío al evitar errores de verificación de clase en la API 28 y versiones anteriores. (aosp/1282118)

Versión 2.3.0-alpha01

4 de marzo de 2020

Lanzamiento de androidx.lifecycle:lifecycle-*:2.3.0-alpha01. La versión 2.3.0-alpha01 contiene estas confirmaciones.

Nuevas funciones

Una nueva API de ViewTreeLifecycleOwner.get(View) te permite recuperar el LifecycleOwner contenedor dado que tiene una instancia de View. Debes actualizar a Activity 1.2.0-alpha01 y Fragment 1.3.0-alpha01 para completarlo correctamente. Hay una extensión de Kotlin de findViewTreeLifecycleOwner disponible en lifecycle-runtime-ktx. (aosp/1182361, aosp/1182956)
Se agregó una nueva verificación de Lint que te avisa al establecer un valor null en un MutableLiveData que se definió en Kotlin como no nulo. Esta función está disponible al usar los artefactos livedata-core-ktx o livedata-ktx. (aosp/1154723, aosp/1159092)
Hay un nuevo artefacto lifecycle-runtime-testing disponible que proporciona un TestLifecycleOwner que implementa LifecycleOwner y proporciona un Lifecycle mutable seguro para subprocesos. (aosp/1242438)

Correcciones de errores

El artefacto lifecycle-runtime ahora tiene un nombre de paquete único. (aosp/1187196)

Versión 2.2.0

ViewModel-SavedState versión 2.2.0

5 de febrero de 2020

Lanzamiento de androidx.lifecycle:lifecycle-viewmodel-savedstate:2.2.0. La versión 2.2.0 contiene estas confirmaciones.

Lifecycle ViewModel SavedState ahora comparte la misma versión que otros artefactos del Lifecycle. El comportamiento de 2.2.0 es idéntico al comportamiento de 1.0.0.

Versión 2.2.0

22 de enero de 2020

Lanzamiento de androidx.lifecycle:lifecycle-*:2.2.0. La versión 2.2.0 contiene estas confirmaciones.

Cambios importantes desde la versión 2.1.0

Integración de la corrutina de Lifecycle: El nuevo artefacto lifecycle-runtime-ktx agrega integración entre las corrutinas de Lifecycle y Kotlin. También se expandió lifecycle-livedata-ktx para aprovechar las corrutinas. Consulta Cómo usar corrutinas de Kotlin con los componentes de la arquitectura para obtener más detalles.
Se dio de baja ViewModelProviders.of(): ViewModelProviders.of() dejó de estar disponible. Puedes pasar un elemento Fragment o FragmentActivity al nuevo constructor ViewModelProvider(ViewModelStoreOwner) para lograr la misma funcionalidad cuando utilizas Fragment 1.2.0
Se dio de baja el artefactolifecycle-extensions: Dado que ViewModelProviders.of() dejó de estar disponible, esta versión marca la baja de la última API en lifecycle-extensions y este artefacto se debería considerar obsoleto en su totalidad. Te recomendamos depender de los artefactos específicos de Lifecycle que necesites (por ejemplo, lifecycle-service si usas LifecycleService, y lifecycle-process si usas ProcessLifecycleOwner) en lugar de utilizar lifecycle-extensions, ya que no habrá una versión 2.3.0 futura de lifecycle-extensions.
Procesador de anotaciones graduales de Gradle: El procesador de anotaciones de Lifecycle es gradual de forma predeterminada. Si tu app está escrita en el lenguaje de programación de Java 8, puedes usar DefautLifecycleObserver. Si está escrita en Java 7, puedes usar LifecycleEventObserver.

Versión 2.2.0-rc03

4 de diciembre de 2019

Lanzamiento de androidx.lifecycle:lifecycle-*:2.2.0-rc03. La versión 2.2.0-rc03 contiene estas confirmaciones.

Correcciones de errores

Se corrigió un error que se producía cuando un objeto ViewModel ficticio se almacenaba en ViewModelStore y se lo solicitaba más tarde con la configuración de fábrica predeterminada.
Corrige un uso de Dispatchers.Main.immediate en launchWhenCreated y métodos similares para que se los llame de forma síncrona durante el evento de ciclo de vida correspondiente. (aosp/1156203)

Contribuciones externas

Gracias a Anders Järleberg por contribuir con la corrección. (aosp/1156203)
Gracias a Vsevolod Tolstopyatov de Jetbrains por revisar una implementación de ejecución intercalada.

Cambios de dependencia

Las extensiones de Lifecycle ahora dependen de Fragment 1.2.0-rc03.

Versión 2.2.0-rc02

7 de noviembre de 2019

Lanzamiento de androidx.lifecycle:lifecycle-*:2.2.0-rc02. La versión 2.2.0-rc02 contiene estas confirmaciones.

Correcciones de errores

Se corrigió un error en la configuración de ProGuard de la biblioteca que afectaba a los dispositivos que ejecutaban API 28+ si la API de destino era inferior a 29 (b/142778206).

Versión 2.2.0-rc01

23 de octubre de 2019

Lanzamiento de androidx.lifecycle:lifecycle-*:2.2.0-rc01. La versión 2.2.0-rc01 contiene estas confirmaciones.

Correcciones de errores

Se corrigió un problema en el que launchWhenCreated y los métodos relacionados ejecutaban un marco más tarde que el método de ciclo de vida asociado debido al uso de Dispatchers.Main, en lugar de Dispatchers.Main.immediate (aosp/1145596).

Contribuciones externas

Gracias a Nicklas Ansman por contribuir con la corrección (aosp/1145596).

Versión 2.2.0-beta01

9 de octubre de 2019

Lanzamiento de androidx.lifecycle:lifecycle-*:2.2.0-beta01. La versión 2.2.0-beta01 contiene estas confirmaciones.

Correcciones de errores

Se corrigió una regresión introducida en Lifecycle 2.2.0-alpha05 en el pedido de ProcessLifecycleOwner y el movimiento de LifecycleOwner de la actividad de inicio y reanudación en dispositivos Android 10. (aosp/1128132)
Se corrigió una regresión introducida en Lifecycle 2.2.0-alpha05 que generaba una NullPointerException al usar la versión 2.0.0 o 2.1.0 de lifecycle-process. (b/141536990).

Versión 2.2.0-alpha05

18 de septiembre de 2019

Lanzamiento de androidx.lifecycle:lifecycle-*:2.2.0-alpha05. La versión 2.2.0-alpha05 contiene estas confirmaciones.

Correcciones de errores

Se corrigió una condición de carrera en el compilador de objetos LiveData de corrutina. (b/140249349)

Versión 2.2.0-alpha04

5 de septiembre de 2019

Lanzamiento de androidx.lifecycle:lifecycle-*:2.2.0-alpha04. Para conocer las confirmaciones incluidas en esta versión, consulta este vínculo.

Nuevas funciones

lifecycleScope, whenCreated, whenStarted, whenResumed, viewModelScope y la implementación subyacente de liveData ahora usan Dispatchers.Main.immediate, en lugar de Dispatchers.Main. (b/139740492).

Contribuciones externas

Gracias a Nicklas Ansman por contribuir con el cambio a Dispatchers.Main.immediate. (aosp/1106073).

Versión 2.2.0-alpha03

7 de agosto de 2019

Lanzamiento de androidx.lifecycle:lifecycle-*:2.2.0-alpha03. Para conocer las confirmaciones incluidas en esta versión, consulta este vínculo.

Nuevas funciones

Las implementaciones de ViewModelStoreOwner ahora tienen la opción de implementar HasDefaultViewModelProviderFactory para proporcionar un valor ViewModelProvider.Factory predeterminado. Este es el caso de This has been done for Activity 1.1.0-alpha02, Fragment 1.2.0-alpha02 y Navigation 2.2.0-alpha01 (aosp/1092370, b/135716331).

Cambios en la API

ViewModelProviders.of() dejó de estar disponible. Puedes pasar un elemento Fragment o FragmentActivity al nuevo constructor ViewModelProvider(ViewModelStoreOwner) para lograr la misma funcionalidad (aosp/1009889).

Versión 2.2.0-alpha02

2 julio de 2019

Lanzamiento de androidx.lifecycle:*:2.2.0-alpha02. Para conocer las confirmaciones incluidas en esta versión, consulta este vínculo.

Cambios en la API

Se reemplazó LiveDataScope.initialValue por LiveDataScope.latestValue, que realizará un seguimiento del valor emitido actual del bloque liveData.
Se agregó una nueva sobrecarga al compilador liveData que recibe el parámetro timeout como Duration de tipo.

Versión 2.2.0-alpha01

7 de mayo de 2019

Lanzamiento de androidx.lifecycle:*:2.2.0-alpha01. Para conocer las confirmaciones incluidas en esta versión, consulta este vínculo.

Nuevas funciones

Esta versión cuenta con nuevas funciones que brindan compatibilidad con las corrutinas de Kotlin para Lifecycle y LiveData. Aquí encontrarás documentación detallada sobre estas.

ViewModel-SavedState versión 1.0.0

Versión 1.0.0

22 de enero de 2020

Lanzamiento de androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0. La versión 1.0.0 contiene estas confirmaciones.

Funciones importantes de la versión 1.0.0

Se agregó una nueva clase SavedStateHandle. Permite que las clases ViewModel accedan y contribuyan al estado guardado. Este objeto se puede recibir en el constructor de la clase ViewModel, y las fábricas proporcionadas de forma predeterminada por Fragments y AppCompatActivity introducirán SavedStateHandle automáticamente.
Se agregó AbstractSavedStateViewModelFactory. Te permite crear fábricas personalizadas para la clase ViewModel y proporcionarles acceso a SavedStateHandle.

ViewModel-Savedstate versión 1.0.0-rc03

4 de diciembre de 2019

Lanzamiento de androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-rc03. La versión 1.0.0-rc03 contiene estas confirmaciones.

Cambios de dependencia

Lifecycle ViewModel SavedState ahora depende de Lifecycle 2.2.0-rc03.

Viewmodel-Savedstate versión 1.0.0-rc02

7 de noviembre de 2019

Lanzamiento de androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-rc02. La versión 1.0.0-rc02 contiene estas confirmaciones.

Cambios de dependencia

Ahora depende de Lifecycle 2.2.0-rc02.

ViewModel-SavedState versión 1.0.0-rc01

23 de octubre de 2019

Lanzamiento de androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-rc01 sin cambios desde 1.0.0-beta01. La versión 1.0.0-rc01 contiene estas confirmaciones.

ViewModel-Savedstate versión 1.0.0-beta01

9 de octubre de 2019

Lanzamiento de androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-beta01. La versión 1.0.0-beta01 contiene estas confirmaciones.

Correcciones de errores

Se corrigió un problema en el que acceder a SavedState ViewModel por primera vez en Activity.onActivityResult() generaba una IllegalStateException. (b/139093676)
Se corrigió una IllegalStateException al usar AbstractSavedStateViewModelFactory. (b/141225984).

ViewModel-SavedState versión 1.0.0-alpha05

18 de septiembre de 2019

Lanzamiento de androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-alpha05. La versión 1.0.0-alpha05 contiene estas confirmaciones.

Cambios en la API

SavedStateViewModelFactory ya no extiende AbstractSavedStateViewModelFactory, y SavedStateHandle se crea solo para las instancias de ViewModels que lo solicitan. (aosp/1113593)

ViewModel-SavedState versión 1.0.0-alpha03

7 de agosto de 2019

Lanzamiento de androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-alpha03. Para conocer las confirmaciones incluidas en esta versión, consulta este vínculo.

Cambios rotundos

lifecycle-viewmodel-savedstate ya no depende de fragment, y se quitaron los constructores SavedStateViewModelFactory(Fragment) y SavedStateViewModelFactory(FragmentActivity) relacionados. En su lugar, SavedStateViewModelFactory ahora es la fábrica predeterminada para Activity 1.1.0-alpha02, Fragment 1.2.0-alpha02 y Navigation 2.2.0-alpha01. (b/135716331).

ViewModel-SavedState versión 1.0.0-alpha02

2 julio de 2019

Lanzamiento de androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-alpha02. Para conocer las confirmaciones incluidas en esta versión, consulta este vínculo.

Nuevas funciones

Se agregó la sobrecarga de SavedStateHandle.getLiveData(), que acepta un valor predeterminado.

Cambios en la API

El nombre de SavedStateVMFactory cambió por SavedStateViewModelFactory.
El nombre de AbstractSavedStateVMFactory cambió por AbstractSavedStateViewModelFactory.

ViewModel-Savedstate versión 1.0.0-alpha01

13 de marzo de 2019

Lanzamiento de androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-alpha01. Para obtener el registro completo de confirmaciones para esta versión inicial, consulta este vínculo.

Nuevas funciones

Ahora, ViewModels puede contribuir con SavedState. Para hacerlo, usa la clase predeterminada SavedStateVMFactory, recientemente introducida, y tu ViewModel debería tener un constructor que reciba el objeto SavedStateHandle como parámetro.

Versión 2.1.0

Cambios importantes desde 2.0.0

Se agregó LifecycleEventObserver para los casos en que se necesita una secuencia de eventos de Lifecycle. Es una API pública, en lugar de una clase GenericLifecycleObserver oculta.
Se agregaron extensiones ktx para los métodos LiveData.observe y Transformations.*.
Se agregó el método Transformations.distinctUntilChanged, que permite crear un nuevo objeto de LiveData que no emite ningún valor hasta que se cambia el valor de origen de LiveData.
Se agregó compatibilidad con corrutinas en ViewModels gracias a que se agregó la propiedad de extensión ViewModel.viewModelScope.

Versión 2.1.0

5 de septiembre de 2019

Lanzamiento de androidx.lifecycle:lifecycle-*:2.1.0. Para conocer las confirmaciones incluidas en esta versión, consulta este vínculo.

Versión 2.1.0-rc01

2 julio de 2019

Lanzamiento de androidx.lifecycle:*:2.1.0-rc01 sin cambios desde androidx.lifecycle:*:2.1.0-beta01. Para conocer las confirmaciones incluidas en esta versión, consulta este vínculo.

Versión 2.1.0-beta01

7 de mayo de 2019

Lanzamiento de androidx.lifecycle:*:2.1.0-beta01. Para conocer las confirmaciones incluidas en esta versión, consulta este vínculo.

Nuevas funciones

Se cambia la versión de Lifecycle a Beta: se estabilizan las API introducidas en las versiones Alfa anteriores, como las funciones de extensión de liveData para transformaciones y observaciones, la inicialización de ViewModel con delegación de propiedades y otras, que no se modificarán.

Versión 2.1.0-alpha04

3 de abril de 2019

Lanzamiento de androidx.lifecycle:*:2.1.0-alpha04. Para conocer las confirmaciones incluidas en esta versión, consulta este vínculo.

Cambios en la API

Cambio rotundo: se cambió la API subyacente detrás de by viewModels() y by activityViewModels() para admitir directamente ViewModelStore, en lugar de solo un ViewModelStoreOwner. (aosp/932932).

Versión 2.1.0-alpha03

13 de marzo de 2019

Lanzamiento de androidx.lifecycle:*:2.1.0-alpha03. Para obtener una lista completa de las confirmaciones incluidas en esta versión, consulta este vínculo.

Cambios en la API

ViewModelProvider.KeyedFactory se quitó. La segunda interfaz, además de ViewModelProvider.Factory, no se ejecutaba correctamente con las nuevas funciones, como delegación de propiedades en by viewmodels {} de Kotlin (aosp/914133).

Versión 2.1.0-alpha02

30 de enero de 2019

Lanzamiento de androidx.lifecycle 2.1.0-alpha02.

Cambios en la API

Ahora LifecycleRegistry contiene un método setCurrentState() que reemplaza el método setState() obsoleto. (aosp/880715).

Correcciones de errores

Se corrigió un problema en el que fallaban las instancias simuladas de ViewModel cuando se borraba el elemento ViewModelStore que las contenía. (b/122273087)

Versión 2.1.0-alpha01

17 de diciembre de 2018

Lanzamiento de androidx.lifecycle 2.1.0-alpha01.

Nuevas funciones

Se agregó LifecycleEventObserver para los casos en que se necesita una secuencia de eventos de Lifecycle. Es una API pública, en lugar de una clase GenericLifecycleObserver oculta.
Se agregaron extensiones ktx para los métodos LiveData.observe y Transformations.*.
Se agregó el método Transformations.distinctUntilChanged. Permite crear un nuevo objeto de LiveData que no emite ningún valor hasta que se cambia el valor de origen de LiveData.
Se agregó la compatibilidad con corrutinas en ViewModels: se agregó la propiedad de extensión ViewModel.viewModelScope.
Se agregó ViewModelProvider.KeyedFactory, un valor de fábrica para ViewModels que recibe key y Class en el método create.

Versión 2.0.0

21 de septiembre de 2018

Lanzamiento de Lifecycle 2.0.0 con una corrección de errores desde 2.0.0-rc01 en ViewModel.

Correcciones de errores

Se corrigió un error de ProGuard de ViewModel que quitaba constructores de manera incorrecta b/112230489

Versión 2.0.0-beta01

2 de julio de 2018

Correcciones de errores

Se corrigió la regla ProGuard de LifecycleObserver solo para mantener implementaciones, y no subinterfaces. b/71389427
Se corrigieron las reglas ProGuard de ViewModel para permitir la ofuscación y la contracción.

Versiones anteriores a AndroidX

Para las siguientes versiones de Lifecycle anteriores a AndroidX, incluye estas dependencias:

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"
}

Versión 1.1.1

21 de marzo de 2018

Solo un pequeño cambio: se movió android.arch.core.util.Function de arch:runtime a arch:common. De esta manera, es posible usarla sin la dependencia del tiempo de ejecución, p. ej., en paging:common a continuación.

lifecycle:common es una dependencia de lifecycle:runtime, de manera que este cambio no afecta a lifecycle:runtime directamente, sino que solo afecta a los módulos que dependen de manera directa de lifecycle:common, como sucede con Paging.

Versión 1.1.0

22 de enero de 2018

Cambios de empaquetado

Ahora hay dependencias nuevas y mucho más pequeñas disponibles:

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

Cambios en la API

Se quitaron LifecycleActivity y LifecycleFragment, ya que dejaron de estar disponibles. En su lugar, usa FragmentActivity o AppCompatActivity, o bien asegúrate de que Fragment sea compatible.
Se agregaron anotaciones de @NonNull a ViewModelProviders y ViewModelStores.
El constructor ViewModelProviders dejó de estar disponible. Usa sus métodos estáticos directamente.
ViewModelProviders.DefaultFactory dejó de estar disponible. Usa ViewModelProvider.AndroidViewModelFactory.
Se agregó el método ViewModelProvider.AndroidViewModelFactory.getInstance(Application) estático para recuperar un valor Factory estático apto para la creación de instancias ViewModel y AndroidViewModel.