Ciclo de vida

Ciclo de vida

Guia do usuário  Exemplo de código  Codelab

Referência da API
androidx.lifecycle

Os componentes compatíveis com o ciclo de vida realizam ações em resposta a uma mudança no status do ciclo de vida de outro componente, como atividades e fragmentos. Esses componentes ajudam a produzir códigos mais organizados e, normalmente, mais leves e mais fáceis de manter.

Esta tabela lista todos os artefatos no grupo androidx.lifecycle.

Artefato	Versão estável	Versão candidata a lançamento	Versão Beta	Versão Alfa
lifecycle-*	2.8,5	-	-	2.9.0-alpha02
lifecycle-viewmodel-compose	2.8,5	-	-	2.9.0-alpha02

Esta biblioteca foi atualizada pela última vez em 4 de setembro de 2024

Declarar dependências

Para adicionar uma dependência ao Lifecycle, é preciso adicionar o repositório Maven do Google ao seu projeto. Leia Repositório Maven do Google para ver mais informações.

Adicione as dependências dos artefatos necessários no arquivo build.gradle para seu app ou módulo:

As APIs em lifecycle-extensions foram descontinuada. Em vez disso, adicione dependências para os artefatos do Lifecycle específicos que você precisa.

Kotlin

Groovy

    dependencies {
        def lifecycle_version = "2.8.5"
        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.5"
        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.5"
        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.5"
        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 ver mais informações sobre dependências, consulte Adicionar dependências de build.

Feedback

Seu feedback ajuda a melhorar o Jetpack. Avise se você descobrir novos problemas ou tiver ideias para melhorar esta biblioteca. Consulte os problemas conhecidos nesta biblioteca antes de criar um novo. Adicione seu voto a um problema clicando no botão de estrela.

Criar novo problema

Consulte a documentação do Issue Tracker para saber mais.

Versão 2.9

Versão 2.9.0-alpha02

4 de setembro de 2024

Lançamento de androidx.lifecycle:lifecycle-*:2.9.0-alpha02. A versão 2.9.0-alpha02 contém estas confirmações.

Correções de bugs

• No Lifecycle 2.8.5: atualize as regras androidx.lifecycle.ReportFragment do ProGuard para permitir a ofuscação . (ff898e1).

Contribuição externa

• Mova androidx.compose.ui.platform.LocalLifecycleOwner para o conjunto de origem comum (KMP). Agradecemos a Ivan Matkov da JetBrains pela contribuição. (8cd5d03).
• No Lifecycle 2.8.5: o delegado da extensão SavedStateHandle.saveable` agora oferece suporte a valores anuláveis. Agradecemos Roman Kalukiewicz pela contribuição. (0d78ea6).

Versão 2.9.0-alpha01

7 de agosto de 2024

Lançamento de androidx.lifecycle:lifecycle-*:2.9.0-alpha01. A versão 2.9.0-alpha01 contém estas confirmações.

Kotlin Multiplatform (link em inglês)

• lifecycle-testing agora é compatível com KMP. (Iea41e).
• Foi adicionado suporte ao destino multiplataforma linuxArm64 do Kotlin (I139d3, b/338268719).

Novos recursos

• Um novo artefato androidx.lifecycle:lifecycle-viewmodel-testing KMP está disponível e fornece uma classe ViewModelScenario para testar ViewModels isoladamente, com suporte a onCleared (todas as plataformas) e SavedStateHandle (somente Android). (337f68d, c9b3409, 9799a95c, b/264602919).
• A criação de um ViewModel com ViewModelProvider agora é segura para linhas de execução: As anotações @MainThread foram removidas. (Ifd978, b/237006831).

Mudanças na API

• Adicione a função de fábrica CreationExtras.Key() para simplificar a criação de objetos CreationExtras.Key anônimos. (I970ee).
• CreationExtras agora inclui sobrecargas de operadores semelhantes a mapas para permitir a manipulação idiomática de conteúdo em Kotlin Ela permite o uso de in, += e + com CreationExtras. (Ib4353).
• CreationExtras agora implementa os métodos equals, hashCode e toString. (Ib4353).
• NewInstanceFactory agora está disponível nos destinos Android e desktop da JVM. (d3d0892).
• Propriedade de extensão inline para expor o aplicativo subjacente com segurança na versão 2.0 da linguagem Kotlin (I39df2).

Correções de bugs

• Remoção da descrição manual do acesso às novas APIs da plataforma, já que isso acontece automaticamente pela modelagem de API ao usar o R8 com o AGP 7.3 ou mais recente (por exemplo, o R8 versão 3.3) e para todos os builds ao usar o AGP 8.1 ou mais recente (por exemplo, o D8 versão 8.1). Os clientes que não usam o AGP são aconselhados a atualizar para o D8 versão 8.1 ou mais recente. Veja mais detalhes neste artigo. (If6b4c, b/345472586).

Versão 2.8

Versão 2.8.5

4 de setembro de 2024

Lançamento de androidx.lifecycle:lifecycle-*:2.8.5. A versão 2.8.5 contém estas confirmações.

Correções de bugs

• Atualize as regras androidx.lifecycle.ReportFragment do ProGuard para permitir a ofuscação . (ff898e1).

Contribuição externa

• O delegado da extensão SavedStateHandle.saveable agora oferece suporte a valores anuláveis. Agradecemos Roman Kalukiewicz pela contribuição. (0d78ea6).

Versão 2.8.4

24 de julho de 2024

Lançamento de androidx.lifecycle:lifecycle-*:2.8.4. A versão 2.8.4 contém estas confirmações.

Correções de bugs

• LiveData.asFlow() agora processa corretamente os casos em que o fluxo retornado é concluído imediatamente depois de receber um valor já definido no LiveData (por exemplo, ao usar take(1)). (I9c566).
• A conclusão de Lifecycle*Effect agora é idempotente, ou seja, se o onStopOrDispose foi chamado devido à interrupção do ciclo de vida, ele não será chamado uma segunda vez após o descarte, a menos que o ciclo de vida volte para STARTED novamente. (I5f607, b/352364595).

Versão 2.8.3

1º de julho de 2024

Lançamento de androidx.lifecycle:lifecycle-*:2.8.3. A versão 2.8.3 contém estas confirmações.

Correções de bugs

• Foi corrigido um problema de compatibilidade do Lifecycle 2.8 com versões anteriores do Compose 1.6.0 e versões anteriores ao usar a redução de código (aosp/3133056, b/346808608).

Versão 2.8.2

12 de junho de 2024

Lançamento de androidx.lifecycle:lifecycle-*:2.8.2. A versão 2.8.2 contém estas confirmações.

Correções de bugs

• Correção de erros CompositionLocal LocalLifecycleOwner not present ao usar o Lifecycle 2.8.X com o Compose 1.6.X ou versões anteriores.Agora você pode usar o Lifecycle 2.8.2 com qualquer versão do Compose sem precisar de soluções alternativas (aosp/3105647, b/336842920).
• O ViewModelProvider não falhará mais ao combinar versões anteriores de dependências do Lifecycle do compileOnly com as versões 2.8+, corrigindo problemas com bibliotecas como LeakCanary (I80383, b/341792251).

Versão 2.8.1

29 de maio de 2024

Lançamento de androidx.lifecycle:lifecycle-*:2.8.1. A versão 2.8.1 contém estas confirmações.

Correções de bugs

• lifecycle-viewmodel-compose agora tem apenas uma dependência comum em compose-runtime, removendo a dependência comum em compose-ui. O artefato do Android mantém o compose-ui para compatibilidade. (aosp/3079334, b/339562627).
• A integração de saveable de ViewModel usando delegados de propriedade agora usa o nome da classe como parte da chave gerada automaticamente, evitando conflitos caso várias classes usem a mesma SavedStateHandle. (osp/3063463, link em inglês).

Versão 2.8.0

14 de maio de 2024

Lançamento de androidx.lifecycle:lifecycle-*:2.8.0. A versão 2.8.0 contém estas confirmações.

Mudanças importantes desde a versão 2.7.0

• O LocalLifecycleOwner foi movido da interface do Compose para lifecycle-runtime-compose para que as APIs auxiliares baseadas no Compose possam ser usadas fora da interface do Compose.
• O artefato lifecycle-runtime-compose agora contém as APIs dropUnlessResumed e dropUnlessStarted, que permitem soltar o clique ou outros eventos que ocorrem mesmo depois que o LifecycleOwner está abaixo do Lifecycle.State especificado. Por exemplo, isso pode ser usado com o Navigation Compose para evitar o processamento de eventos de clique após o início de uma transição para outra tela: onClick: () -> Unit = dropUnlessResumed { navController.navigate(NEW_SCREEN) }

• ViewModel.viewModelScope agora é um parâmetro de construtor substituível, permitindo que você injete seu próprio dispatcher e SupervisorJob() ou substitua o padrão usando o backgroundScope disponível em 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)
  }
  

• O ViewModel foi reescrito em Kotlin e agora usa AutoClosable em vez de Closeable. Agora, ele oferece suporte à adição de objetos AutoCloseable com um key que permite os extrair usando getCloseable().

• Chamar LifecycleStartEffect e LifecycleResumeEffect sem uma chave agora é um erro, seguindo a mesma convenção da API DisposableEffect que essas APIs espelham.

• O uso de LiveDataReactiveStreams.toPublisher(lifecycleOwner, liveData) foi descontinuado e substituído por LiveData.toPublisher(lifecycleOwner).

• As extensões Kotlin lifecycle-livedata-core-ktx foram movidas para o módulo lifecycle-livedata-core.

• O NullSafeMutableLiveData foi refatorado para evitar muitos falsos positivos.

Compatibilidade com várias plataformas do Kotlin no Lifecycle (link em inglês)

As principais APIs Lifecycle em Lifecycle, LifecycleOwner, LifecycleObserver, Lifecycle.State, Lifecycle.Event e LifecycleRegistry agora são enviadas em artefatos compatíveis com o Kotlin Multiplatform.

Artefatos afetados:

• lifecycle-common move a maioria das APIs para common e oferece suporte a jvm e iOS, além do Android.
• lifecycle-runtime move a maioria das APIs para common e oferece suporte a jvm e iOS, além do Android.
• lifecycle-runtime-ktx agora está vazio, com todas as APIs sendo movidas para lifecycle-runtime.
• O lifecycle-runtime-compose move todas as APIs para common e envia um artefato do Android, correspondendo ao suporte multiplataforma de androidx.compose.

Compatibilidade multiplataforma do Kotlin do ViewModel

O artefato lifecycle-viewmodel e as APIs, como ViewModel, ViewModelStore, ViewModelStoreOwner e ViewModelProvider, agora são enviados em artefatos compatíveis com o Kotlin Multiplatform.

Para acomodar essa mudança, métodos como os em ViewModelProvider, que usavam uma java.lang.Class<T>, agora têm um método equivalente que usa uma kotlin.reflect.KClass<T>.

A compatibilidade binária no Android foi mantida, mas há algumas mudanças notáveis ao comparar a superfície da API do Android com a superfície da API comum:

• A criação de uma instância ViewModelProvider agora é feita pelos métodos ViewModelProvider.create() em vez de chamar diretamente o construtor.
• ViewModelProvider.NewInstanceFactory e ViewModelProvider.AndroidViewModelFactory estão disponíveis apenas no Android.
  • Recomendamos que as fábricas personalizadas sejam estendidas do ViewModelProvider.Factory e usem o método create, que usa um CreationExtras ou a DSL viewModelFactory do Kotlin.
• O uso de ViewModelProvider sem uma fábrica personalizada em plataformas não JVM vai resultar em uma UnsupportedOperationException. Em plataformas JVM, a compatibilidade será preservada usando o construtor ViewModel no-args se uma fábrica personalizada não for fornecida.
• O viewModelScope será substituído por um EmptyCoroutineContext nas plataformas em que Dispatchers.Main não estiver disponível (por exemplo, Linux).

Artefatos afetados:

• lifecycle-viewmodel move a maioria das APIs para common e oferece suporte a jvm e iOS, além do Android.
• lifecycle-viewmodel-ktx agora está vazio, com todas as APIs sendo movidas para lifecycle-viewmodel.
• O lifecycle-viewmodel-compose move todas as APIs para common e envia um artefato do Android, correspondendo ao suporte multiplataforma de androidx.compose.

Mudanças de comportamento

• InitializerViewModelFactory (incluindo a função do builder viewModelFactory) agora vai gerar uma IllegalArgumentException se um initializer com o mesmo clazz: KClass<VM : ViewModel> já tiver sido adicionado (Ic3a36).

Problemas conhecidos

• lifecycle-*:2.8.0 requer uma versão mínima do Compose de 1.7.0-alpha05 (b/336842920).

Versão 2.8.0-rc01

1o de maio de 2024

Lançamento de androidx.lifecycle:lifecycle-*:2.8.0-rc01. A versão 2.8.0-rc01 contém estas confirmações.

Correções de bugs

• Correção de um problema em que o perfil de referência para classes lifecycle-common não era empacotado corretamente. Eles agora estão empacotados no AAR de lifecycle-runtime. (aosp/3038274, b/322382422).
• Foi corrigida uma mudança não intencional de ordem na forma como as instâncias AutoCloseable anexadas a um ViewModel são apagadas. A ordem anterior de addCloseable(String, AutoCloseable), depois addClosable(AutoCloseable) e depois onCleared() foi restaurada. (osp/3041632, link em inglês).
• Melhoria no comportamento de criação padrão de viewModelScope para ambientes de desktop nativos e do JVM (osp/3039221, link em inglês).

Contribuição externa

• Agradecemos a Victor Kropp por melhorar a verificação da linha de execução principal no JVM Desktop. (osp/3037116, link em inglês).

Versão 2.8.0-beta01

17 de abril de 2024

Lançamento de androidx.lifecycle:lifecycle-*:2.8.0-beta01. A versão 2.8.0-beta01 contém estas confirmações.

Novos recursos

• O artefato lifecycle-runtime-compose agora é compatível com o Kotlin Multiplatform, movendo o código para common e envia um artefato Android, correspondendo ao suporte multiplataforma para androidx.compose (If7a71, I4f4a0, b/331769623).

Versão 2.8.0-alpha04

3 de abril de 2024

Lançamento de androidx.lifecycle:lifecycle-*:2.8.0-alpha04. A versão 2.8.0-alpha04 contém estas confirmações.

Novos recursos

• O artefato lifecycle-viewmodel-compose agora é compatível com o Kotlin Multiplatform, movendo o código para common e envia um artefato Android, correspondendo ao suporte multiplataforma de androidx.compose. Para acomodar essa mudança, o método viewModel combinável agora aceita um KClass, além de um java.lang.Class. (b/330323282).

Correções de bugs

• O NullSafeMutableLiveData foi refatorado para evitar muitos falsos positivos. (I2d8c1, Iafb18, I03463, I7ecef).

Atualização de dependências

• O artefato lifecycle-viewmodel-compose agora depende do Compose 1.6.0.
• O Lifecycle agora depende do Profile Installer 1.3.1.

Versão 2.8.0-alpha03

20 de março de 2024

Lançamento de androidx.lifecycle:lifecycle-*:2.8.0-alpha03. A versão 2.8.0-alpha03 contém estas confirmações.

Novos recursos

• ViewModel.viewModelScope agora é um parâmetro de construtor substituível, permitindo que você injete seu próprio dispatcher e SupervisorJob() ou substitua o padrão usando o backgroundScope disponível em 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)
  }
  

Compatibilidade multiplataforma do Kotlin (link em inglês)

O artefato lifecycle-viewmodel e as APIs, como ViewModel, ViewModelStore, ViewModelStoreOwner e ViewModelProvider, agora são enviados em artefatos compatíveis com o Kotlin Multiplatform. (b/214568825).

Para acomodar essa mudança, métodos como os em ViewModelProvider, que usavam uma java.lang.Class<T>, agora têm um método equivalente que usa uma kotlin.reflect.KClass<T>.

A compatibilidade binária no Android foi mantida, mas há algumas mudanças notáveis ao comparar a superfície da API do Android com a superfície da API comum:

• A criação de uma instância ViewModelProvider agora é feita pelos métodos ViewModelProvider.create() em vez de chamar diretamente o construtor.
• ViewModelProvider.NewInstanceFactory e ViewModelProvider.AndroidViewModelFactory estão disponíveis apenas no Android.
  • Recomendamos que as fábricas personalizadas sejam estendidas do ViewModelProvider.Factory e usem o método create, que usa um CreationExtras ou a DSL viewModelFactory do Kotlin.
• O uso de ViewModelProvider sem uma fábrica personalizada em plataformas não JVM vai resultar em uma UnsupportedOperationException. Em plataformas JVM, a compatibilidade será preservada usando o construtor ViewModel no-args se uma fábrica personalizada não for fornecida.
• O viewModelScope será substituído por um EmptyCoroutineContext nas plataformas em que Dispatchers.Main não estiver disponível (por exemplo, Linux).

Mudanças de comportamento

• InitializerViewModelFactory (incluindo a função do builder viewModelFactory) agora vai gerar uma IllegalArgumentException se um initializer com o mesmo clazz: KClass<VM : ViewModel> já tiver sido adicionado (Ic3a36).

Correções de bugs

• ViewModel.getCloseable agora lida com chaves duplicadas: se o key já tiver um recurso AutoCloseable associado a ele, o recurso antigo será substituído e fechado imediatamente. (Ibeb67).
• O acesso ao viewModelScope de um ViewModel agora é thread-safe. (If4766, b/322407038).

Contribuição externa

• O LocalLifecycleOwner foi movido da interface do Compose para o lifecycle-runtime-compose, para que as APIs auxiliares baseadas no Compose possam ser usadas fora da interface do Compose. Agradecemos a Jake Wharton pela contribuição. (I6c41b, b/328263448).

Versão 2.8.0-alpha02

21 de fevereiro de 2024

Lançamento de androidx.lifecycle:lifecycle-*:2.8.0-alpha02. A versão 2.8.0-alpha02 contém estas confirmações.

Novos recursos

• As APIs dropUnlessResumed e dropUnlessStarted foram adicionadas, o que permite soltar cliques ou outros eventos que ocorrem mesmo depois que LifecycleOwner fica abaixo do Lifecycle.State especificado. Por exemplo, isso pode ser usado com o Navigation Compose para evitar o processamento de eventos de clique após o início de uma transição para outra tela: onClick: () -> Unit = dropUnlessResumed { navController.navigate(NEW_SCREEN) } (Icba83, b/317230685).

Conversões para Kotlin

• ViewModel agora é escrito em Kotlin (I16f26, b/214568825).
• As extensões Kotlin lifecycle-viewmodel-ktx foram movidas para o módulo do ciclo de vida básico. (Id787b, b/274800183).
• As extensões Kotlin lifecycle-runtime-ktx foram movidas para o módulo do ciclo de vida básico. (Ic3686, b/274800183).
• As extensões Kotlin lifecycle-livedata-core-ktx foram movidas para o módulo do ciclo de vida básico. (I54a3d, b/274800183).

Compatibilidade multiplataforma do Kotlin (link em inglês)

• As principais APIs Lifecycle em Lifecycle, LifecycleOwner, LifecycleObserver, Lifecycle.State, Lifecycle.Event e LifecycleRegistry agora são enviadas em artefatos compatíveis com o Kotlin Multiplatform. (b/317249252).

Mudanças na API

• Chamar LifecycleStartEffect e LifecycleResumeEffect sem uma chave agora é um erro, seguindo a mesma convenção da API DisposableEffect que essas APIs espelham. (Ib0e0c, b/323518079).
• ViewModel agora usa AutoCloseable em vez de Closeable Essa é uma alteração compatível com versões anteriores. (I27f8e, b/214568825).
• O uso de LiveDataReactiveStreams.toPublisher(lifecycleOwner, liveData) foi descontinuado e substituído por LiveData.toPublisher(lifecycleOwner). (Iabe29, b/262623005).

Contribuição externa

• Agradecemos a Ivan Matkov da Jetbrains por ajudar a migrar o Lifecycle para o Kotlin Multiplatform. (aosp/2926690, I0c5ac, If445d).

Versão 2.8.0-alpha01

24 de janeiro de 2024

Lançamento de androidx.lifecycle:lifecycle-*:2.8.0-alpha01. A versão 2.8.0-alpha01 contém estas confirmações.

Novos recursos

• ViewModel agora oferece suporte à adição de objetos Closeable com um key que permite os extrair por meio de getCloseable() (I3cf63).

Versão 2.7

Versão 2.7.0

10 de janeiro de 2024

Lançamento de androidx.lifecycle:lifecycle-*:2.7.0. A versão 2.7.0 contém estas confirmações.

Mudanças importantes desde a versão 2.6.0

• TestLifecycleOwner agora inclui uma função de suspensão setCurrentState() que garante que a mudança de estado e todos os callbacks de LifecycleObserver sejam concluídos antes do retorno É importante ressaltar que, ao contrário da configuração direta da propriedade currentState, ele não usa runBlocking, o que o torna seguro em uma corrotina como a fornecida por runTest.
• As extensões LiveData de map e switchMap agora espelham o comportamento de distinctUntilChanged. Se o LiveData tiver um value definido, a função map/switchMap será chamada imediatamente para preencher o value do LiveData retornado. Isso garante que o valor inicial seja definido como parte da primeira composição (quando usado com observeAsState()), mas não muda o comportamento de observação. As atualizações da LiveData de origem ainda vão ser aplicadas apenas quando você começar a observar o LiveData.
• Esta versão corrige um problema em que o SavedStateHandle não restaurava corretamente as classes Parcelable personalizadas após o encerramento e a recriação do processo. Devido às informações de tipo perdidas pelo framework do Android, as matrizes de Parcelables personalizados exigem mais trabalho (criando manualmente uma matriz tipada do tipo correto), e a documentação sobre get, getLiveData e getStateFlow agora chama especificamente essa limitação.
• As regras keep do ProGuard associadas a LifecycleObserver foram removidas. Isso significa que o código ProGuard que quiser usar APIs por reflexão (como o uso da anotação @OnLifecycleEvent há muito tempo descontinuada) vai precisar fornecer as próprias regras keep para o caso de uso específico.

Observabilidade de eventos do ciclo de vida

• Como alternativa ao uso de um LifecycleEventObserver, agora você pode observar um Flow de Lifecycle.Event usando o método de extensão Lifecycle.asFlow().
• Os usuários do Jetpack Compose agora podem usar LifecycleEventEffect para executar efeitos colaterais do Compose com base em Lifecycle.Event.

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

• Os usuários do Jetpack Compose podem usar LifecycleStartEffect e LifecycleResumeEffect para processar pares de eventos, iniciados para interrompidos e retomados para pausados, respectivamente. Essa API espelha a encontrada em DisposableEffect e é adequada para casos em que a mudança feita quando o estado está subindo precisa ser revertida ao voltar para baixo.

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

Consulte Executar código em eventos de ciclo de vida para mais informações.

Observabilidade do estado do ciclo de vida

• O Lifecycle.State atual agora pode ser observado pela propriedade Lifecycle.currentStateFlow, que retorna um StateFlow em que value é o Lifecycle.State atual.
• Os usuários do Jetpack Compose podem usar a extensão Lifecycle.currentStateAsState() para expor diretamente Lifecycle.State como State do Compose. Isso é equivalente (e uma alternativa mais curta) a lifecycle.currentStateFlow.collectAsState().

Consulte Coletar o estado do ciclo de vida com fluxos para mais informações.

Versão 2.7.0-rc02

13 de dezembro de 2023

Lançamento de androidx.lifecycle:lifecycle-*:2.7.0-rc02. A versão 2.7.0-rc02 contém estas confirmações.

Correções de bugs

• Correção de um problema em que SavedStateHandle não restaurava corretamente classes Parcelable personalizadas após o encerramento e a recriação do processo Devido às informações de tipo perdidas pelo framework do Android, as matrizes de Parcelables personalizados exigem mais trabalho (criando manualmente uma matriz tipada do tipo correto), e a documentação sobre get, getLiveData e getStateFlow agora chama especificamente essa limitação. (I0b55a).

Versão 2.7.0-rc01

15 de novembro de 2023

Lançamento de androidx.lifecycle:lifecycle-*:2.7.0-rc01. A versão 2.7.0-rc01 contém estas confirmações.

Correções de bugs

• LifecycleStartEffect e LifecycleResumeEffect agora descartam e recriam corretamente o bloco de efeito se o LifecycleOwner for mudado. (Ia25c6).

Versão 2.7.0-beta01

1º de novembro de 2023

Lançamento de androidx.lifecycle:lifecycle-*:2.7.0-beta01 sem mudanças. A versão 2.7.0-beta01 contém estas confirmações.

• Uma versão Beta, sem grandes mudanças nesta versão de lançamento.

Versão 2.7.0-alpha03

18 de outubro de 2023

Lançamento de androidx.lifecycle:lifecycle-*:2.7.0-alpha03. A versão 2.7.0-alpha03 contém essas confirmações.

Novos recursos

• lifecycle-runtime-testing agora contém uma nova verificação de lint para evitar a configuração do Lifecycle.State do TestLifecycleOwner usando o campo currentState quando dentro de uma corrotina. A verificação de lint agora sugere a suspensão setCurrentState, que permite definir o Lifecycle.State sem bloqueios (Icf728, b/297880630).

Correções de bugs

• Correção de um problema com LiveData.switchMap em que retornar a mesma instância de LiveData na chamada inicial e em uma chamada seguinte impedia que a instância LiveData fosse adicionada como uma origem (Ibedcba7).

Versão 2.7.0-alpha02

6 de setembro de 2023

Lançamento de androidx.lifecycle:lifecycle-*:2.7.0-alpha02. A versão 2.7.0-alpha02 contém estas confirmações.

Novos recursos

• TestLifecycleOwner agora inclui a função de suspensão setCurrentState() para oferecer aos usuários a opção de usar TestLifecycleOwner em uma corrotina, como a fornecida por runTest. (I329de, b/259344129).

Mudanças na API

• Todos os arquivos dos módulos lifecycle-livedata-ktx foram movidos para o módulo lifecycle-livedata principal. (I10c6f, b/274800183).

Mudanças de comportamento

• As extensões LiveData.map() e LiveData.switchMap() agora definem o value do LiveData retornado se o LiveData anterior tiver um valor definido, garantindo que o uso do LiveData resultante no Jetpack Compose tenha o estado certo na composição inicial. (I91d2b, b/269479952).
• O addCloseable() do ViewModel agora fecha imediatamente a Closeable se o ViewModel já recebeu uma chamada para onCleared() (I4712e, b/280294730).

Correções de bugs

• No Lifecycle 2.6.2: foi corrigido um problema em que SavedStateHandle não era restaurado corretamente após a interrupção do processo se o estado fosse restaurado. save() era chamado sem realmente salvar o estado no SavedStateRegistry pai e, em seguida, o estado era restaurado novamente Isso corrige a interação entre a rememberSaveable e o NavHost do Navigation Compose. (osp/2729289, link em inglês).

Versão 2.7.0-alpha01

26 de julho de 2023

Lançamento de androidx.lifecycle:lifecycle-*:2.7.0-alpha01. A versão 2.7.0-alpha01 contém estas confirmações

Mudanças na API

• O Lifecycle.State agora pode ser observado pelo Compose via Lifecycle.currentStateFlow, que retorna um StateFlow em que o value é o Lifecycle.State atual. (Ib212d, b/209684871).
• Lifecycle.Events agora podem ser observados como um Flow com Lifecycle.asFlow(). (If2c0f, b/176311030).
• A API LifecycleResumeEffect foi adicionada para executar SideEffects do Compose com base em callbacks de eventos Lifecycle.Event.ON_RESUME e Lifecycle.Event.ON_PAUSE. (I60386, b/235529345).
• A API LifecycleStartEffect foi adicionada para executar SideEffects do Compose com base em callbacks de eventos Lifecycle.Event.ON_START e Lifecycle.Event.ON_STOP. (I5a8d1, b/235529345).
• A API LifecycleEventEffect foi adicionada para executar SideEffects do Compose com base em Lifecycle.Event. (Ic9794, b/235529345).
• A extensão Lifecycle.collectAsState() foi adicionada para expor diretamente o Lifecycle.State como State do Compose. Isso é equivalente (e uma alternativa mais curta) a lifecycle.currentStateFlow.collectAsState(). (I11015, b/235529345).

Correções de bugs

• Agora, a extensão LiveData.distinctUntilChanged() define o value do LiveData retornado quando o LiveData anterior tem um valor definido. Isso não muda o comportamento de observação. Os valores atualizados do LiveData de origem ainda serão aplicados apenas quando você começar a observar o LiveData retornado de distinctUntilChanged() (Ib482f).
• As regras keep do ProGuard associadas a LifecycleObserver foram removidas. Isso significa que o código ProGuard que quiser usar APIs por reflexão vai precisar fornecer as próprias regras Keep para o caso de uso específico. (Ia12fd).

Versão 2.6

Versão 2.6.2

6 de setembro de 2023

Lançamento de androidx.lifecycle:lifecycle-*:2.6.2. A versão 2.6.2 contém estas confirmações.

Correções de bugs

• Correção de um problema em que SavedStateHandle não era restaurado corretamente após a interrupção do processo quando o estado era restaurado, save() era chamado sem realmente salvar o estado no SavedStateRegistry pai e, em seguida, o estado era restaurado novamente Isso corrige a interação entre a rememberSaveable e o NavHost do Navigation Compose. (osp/2729289, link em inglês).

Versão 2.6.1

22 de março de 2023

Lançamento de androidx.lifecycle:lifecycle-*:2.6.1. A versão 2.6.1 contém estas confirmações.

Atualizações de dependência

• lifecycle-viewmodel-savedstate agora depende de SavedState 1.2.1. (cd7251).
• O Lifecycle agora depende do ProfileInstaller 1.3.0. (f9d30b).

Versão 2.6.0

8 de março de 2023

Lançamento de androidx.lifecycle:lifecycle-*:2.6.0. A versão 2.6.0 contém estas confirmações.

Mudanças importantes desde a versão 2.5.0

• LiveData agora inclui uma nova propriedade isInitialized que indica se um valor explícito já foi definido no LiveData. Isso permite distinguir entre liveData.value que retorna null porque nenhum valor foi definido ou um valor null explícito
• MediatorLiveData agora inclui um construtor para definir um valor inicial
• Foi adicionada uma nova extensão em StateFlow e Flow de collectAsStateWithLifecycle() que coleta de fluxos e representa o valor mais recente como estado do Compose, considerando o ciclo de vida.
• Os métodos Lifecycle.launchWhenX e Lifecycle.whenX foram descontinuados, já que o uso de um agente de pausa pode gerar recursos desnecessários. É recomendável usar Lifecycle.repeatOnLifecycle Para mais informações sobre a suspensão única de trabalho, consulte esta explicação sobre por que isso é inerentemente não seguro.
• Conversão de Kotlin: um grande número de classes de ciclo de vida foi convertido para Kotlin. Todas as classes convertidas ainda mantêm a compatibilidade binária com as versões anteriores. As seguintes classes têm mudanças incompatíveis com a origem para classes escritas em Kotlin: ViewTreeLifecycleOwner, LiveDataReactiveStreams, HasDefaultViewModelProviderFactory, ViewTreeViewModelStoreOwner, Transformations, ViewModelStoreOwner, LifecycleOwner

A tabela abaixo mostra as conversões de origem da nova versão do ciclo de vida.

Ciclo de vida 2.5	Lifecycle 2.5 (KTX)	Ciclo de vida 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

• A nulidade do método onChanged de um Observer criado em Kotlin agora corresponde à nulidade do tipo genérico Se você quiser que Observer.onChanged() aceite um tipo anulável, instanciar Observer com um tipo anulável.
• Estas classes também foram convertidas para Kotlin, mas continuam compatíveis com a origem: DefaultLifecycleObserver, LifecycleEventObserver, Lifecycle, LifecycleRegistry, LifecycleObserver, ViewModelStore, AndroidViewModel, AbstractSavedStateViewModelFactory, LifecycleService, ServiceLifecycleDispatcher e ProcessLifecycleOwner

Versão 2.6.0-rc01

22 de fevereiro de 2023

Lançamento de androidx.lifecycle:lifecycle-*:2.6.0-rc01. A versão 2.6.0-rc01 contém estas confirmações.

Correções de bugs

• Agora, a extensão LiveData.distinctUntilChanged() define o value do LiveData retornado quando o LiveData anterior tem um valor definido. Isso não muda o comportamento de observação. Os valores atualizados do LiveData de origem ainda serão aplicados apenas quando você começar a observar o LiveData retornado de distinctUntilChanged() (Ib482f).

Versão 2.6.0-beta01

8 de fevereiro de 2023

Lançamento de androidx.lifecycle:lifecycle-*:2.6.0-beta01. A versão 2.6.0-beta01 contém estas confirmações.

Conversões para Kotlin

• Agora, o LifecycleOwner é escrito em Kotlin. Essa é uma mudança incompatível com a fonte das classes escritas em Kotlin. Elas precisam substituir a propriedade lifecycle em vez de implementar a função getLifecycle() anterior (I75b4b, b/240298691).
• Agora, o ViewModelStoreOwner é escrito em Kotlin. Essa é uma mudança incompatível com a fonte das classes escritas em Kotlin. Elas precisam substituir a propriedade viewModelStore em vez de implementar a função getViewModelStore() anterior (I86409, b/240298691).
• A extensão Kotlin em LifecycleOwner que fornece o campo lifecycleScope foi movida para o artefato lifecycle-common de lifecycle-runtime-ktx (I41d78, b/240298691).
• A extensão Kotlin em Lifecycle que fornece o campo coroutineScope foi movida para o artefato lifecycle-common de lifecycle-runtime-ktx (Iabb91, b/240298691).

Versão 2.6.0-alpha05

25 de janeiro de 2023

Lançamento de androidx.lifecycle:lifecycle-*:2.6.0-alpha05. A versão 2.6.0-alpha05 contém estas confirmações.

Conversões para Kotlin

• Agora, as Transformations são escritas em Kotlin. Essa é uma mudança incompatível com a origem das classes escritas em Kotlin que usavam sintaxe direta, como Transformations.map. O código Kotlin precisa usar a sintaxe do método de extensão Kotlin, que antes estava disponível apenas ao usar o lifecycle-livedata-ktx. Ao usar a linguagem de programação Java, as versões desses métodos que usam um androidx.arch.core.util.Function são descontinuadas e substituídas pelas versões que usam uma Function1 do Kotlin. Essa mudança mantém a compatibilidade com binários (I8e14f).
• Agora, o ViewTreeViewModelStoreOwner é escrito em Kotlin. Essa é uma mudança incompatível com a origem das classes escritas em Kotlin. É necessário importar e usar diretamente os métodos de extensão Kotlin na View de androidx.lifecycle.setViewTreeViewModelStoreOwner e androidx.lifecycle.findViewTreeViewModelStoreOwner para definir e encontrar um proprietário configurado anteriormente. Ela é compatível com binários e mantém a compatibilidade com origens das implementações escritas na linguagem de programação Java (Ia06d8, Ib22d8, b/240298691).
• Agora, a interface HasDefaultViewModelProviderFactory é escrita em Kotlin. Essa é uma mudança incompatível com a origem de classes escritas em Kotlin. Elas precisam substituir as propriedades defaultViewModelProviderFactory e defaultViewModelCreationExtras, em vez de implementar as funções correspondentes anteriores (Iaed9c, b/240298691).
• Agora, o Observer é escrito em Kotlin. O método onChanged() usa o value de nome como parâmetro (Iffef2, I4995e, b/240298691).
• AndroidViewModel, AbstractSavedStateViewModelFactory, LifecycleService, ServiceLifecycleDispatcher e ProcessLifecycleOwner agora são escritos em Kotlin (I2e771, Ibae40, I160d7, I08884, I1cda7, b/240298691).

Versão 2.6.0-alpha04

11 de janeiro de 2023

Lançamento de androidx.lifecycle:lifecycle-*:2.6.0-alpha04. A versão 2.6.0-alpha04 contém estas confirmações.

Novos recursos

• LiveData agora inclui uma nova propriedade isInitialized que indica se um valor explícito já foi definido no LiveData. Isso permite distinguir entre liveData.value que retorna null porque nenhum valor foi definido ou um valor null explícito (Ibd018).

Mudanças na API

• As APIs collectAsStateWithLifecycle() de lifecycle-runtime-compose não estão mais no status experimental (I09d42, b/258835424).
• Os métodos Lifecycle.launchWhenX e Lifecycle.whenX foram descontinuados, já que o uso de um agente de pausa pode gerar recursos desnecessários. É recomendável usar Lifecycle.repeatOnLifecycle (Iafc54, b/248302832).

Conversões para Kotlin

• Agora, ViewTreeLifecycleOwner é escrito em Kotlin. Essa é uma mudança incompatível com a origem das classes escritas em Kotlin. É necessário importar e usar diretamente os métodos de extensão Kotlin na View de androidx.lifecycle.setViewTreeLifecycleOwner e androidx.lifecycle.findViewTreeLifecycleOwner para definir e encontrar um proprietário configurado anteriormente. Isso substitui a extensão Kotlin anterior em lifecycle-runtime-ktx. Ela é compatível com binários e mantém a compatibilidade com origens das implementações escritas na linguagem de programação Java (I8a77a, I5234e, b/240298691).
• Agora, LiveDataReactiveStreams é escrito em Kotlin. As extensões Kotlin que ficavam anteriormente em lifecycle-reactivestreams-ktx foram movidas para o módulo lifecycle-reactivestreams e se tornaram a superfície principal para o código escrito em Kotlin. Essa é uma mudança incompatível com a origem do código escrito em Kotlin se você ainda não estivesse usando as APIs do método de extensão Kotlin (I2b1b9, I95d22, b/240298691).
• Agora, DefaultLifecycleObserver, LifecycleEventObserver, Lifecycle, LifecycleRegistry, LifecycleObserver e ViewModelStore estão escritos em Kotlin (Iadffd, I60034, I8c52c, I9593d, I01fe1, I59a23, b/240298691).

Correções de bugs

• SavedStateHandle não falha mais com um ClassCastException ao chamar get() com o tipo de classe incorreto (I6ae7c).

Versão 2.6.0-alpha03

24 de outubro de 2022

Lançamento de androidx.lifecycle:lifecycle-*:2.6.0-alpha03. A versão 2.6.0-alpha03 contém estas confirmações.

Correções de bugs

• Corrigido um problema com restrições entre diferentes módulos do Lifecycle que não funcionavam conforme o esperado (I18d0d, b/249686765).
• Os erros gerados por LifecycleRegistry.moveToState() agora incluem uma mensagem de erro mais útil que informa aos desenvolvedores o componente que causa o erro (Idf4b2, b/244910446).

Versão 2.6.0-alpha02

7 de setembro de 2022

Lançamento de androidx.lifecycle:lifecycle-*:2.6.0-alpha02. A versão 2.6.0-alpha02 contém estas confirmações.

Mudanças na API

• MediatorLiveData agora inclui um construtor para definir um valor inicial (Ib6cc5, b/151244085).

Correções de bugs

• Os artefatos Lifecycle agora incluem restrições (link em inglês) que garantem que todos os artefatos do ciclo de vida que são interdependentes usem a mesma versão, fazendo upgrade automático de outras dependências quando um for atualizado b/242871265.
• FlowLiveData.asFlow() agora cria um callbackFlow em vez de usar a própria implementação do Channel para garantir a segurança de linhas de execução e a preservação de contexto (I4a8b2, b/200596935).
• A função asLiveData do FlowLiveData agora preserva o valor inicial de um StateFlow ao criar o novo objeto LiveData (I3f530, b/157380488).
• Do Lifecycle 2.5.1: as implementações personalizadas de AndroidViewModelFactory agora chamam corretamente a função create(modelClass) ao usar o construtor com estado com o Lifecycle 2.4 ou versões mais recentes (I5b315, b/238011621).

Versão 2.6.0-alpha01

29 de junho de 2022

androidx.lifecycle:lifecycle-*:2.6.0-alpha01 é lançado. A versão 2.6.0-alpha01 contém estas confirmações.

Novos recursos

• Adicionada uma nova extensão no StateFlow e Flow de collectAsStateWithLifecycle, que realiza as coletas dos fluxos e representa o valor mais recente dele como estado do Compose, considerando o ciclo de vida. O fluxo é coletado, e a nova emissão é definida como o valor do estado quando o ciclo de vida está pelo menos em um determinado Lifecycle.State. Quando o ciclo de vida fica abaixo desse Lifecycle.State, a coleta do fluxo é interrompida, e o valor do estado não é atualizado (I1856e, b/230557927).

Versão 2.5

Versão 2.5.1

27 de julho de 2022

Lançamento de androidx.lifecycle:lifecycle-*:2.5.1. A versão 2.5.1 contém estas confirmações.

Correções de bugs

• As implementações personalizadas de AndroidViewModelFactory agora chamam corretamente a função create(modelClass) ao usar o construtor AndroidViewModelFactory com estado com o Lifecycle 2.4 ou mais recente (I5b315, b/238011621).

Versão 2.5.0

29 de junho de 2022

Lançamento de androidx.lifecycle:lifecycle-*:2.5.0. A versão 2.5.0 contém estas confirmações.

Mudanças importantes desde a versão 2.4.0

• O parâmetro SavedStateHandle agora oferece uma API getStateFlow() que retorna um StateFlow do Kotlin para monitorar mudanças de valor como umaalternativa ao uso de LiveData.

• ViewModel CreationExtras: ao gravar um ViewModelProvider.Factory personalizado, não é mais necessário estender AndroidViewModelFactory ou AbstractSavedStateViewModelFactory para ter acesso a um Application ou SavedStateHandle, respectivamente. Em vez disso, esses campos são fornecidos a todas as subclasses ViewModelProvider.Factory como CreationExtras com a nova sobrecarga de create: create(Class<T>, CreationExtras). Esses extras são fornecidos automaticamente pela atividade ou pelo fragmento ao usar a Activity 1.5.0 e o 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
      }
  }
  

• O lifecycle-viewmodel agora fornece uma DSL viewModelFactory do Kotlin que permite definir seu ViewModelProvider.Factory em termos de um ou mais inicializadores de lambda, um para cada classe ViewModel com suporte para a fábrica personalizada, usando CreationExtras como a fonte de dados principal.

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

• O lifecycle-viewmodel-compose agora oferece uma API viewModel() que usa uma fábrica de lambdas para criar uma instância do ViewModel sem exigir a criação de uma 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)
  }
  

• Integração do SavedStateHandle para economia no Compose: o artefato lifecycle-viewmodel-compose agora contém novas APIs experimentais em SavedStateHandle.saveable que permitem um comportamento similar ao rememberSaveable apoiado pelo SavedStateHandle de um ViewModel.

  class ListScreenViewModel(handle: SavedStateHandle): ViewModel() {
      // This value survives both configuration changes and process death and recreation
      val editMode by handle.saveable { mutableStateOf(false) }
  }
  

• Adicionamos uma API addCloseable() e uma nova sobrecarga de construtor que permite adicionar um ou mais objetos Closeable ao ViewModel que são fechados quando o ViewModel é apagado sem exigir trabalhos manuais em onCleared().

  Por exemplo, para criar um escopo de corrotina que possa ser injetado em um ViewModel e controlado por testes, você pode criar um CoroutineScope que implemente Closeable:

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

  Ele pode ser usado no construtor ViewModel e manter o mesmo ciclo de vida do viewModelScope:

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

Mudanças de comportamento

• A tentativa de mover o Lifecycle.State de INITIALIZED para DESTROYED agora sempre vai gerar uma IllegalStateException, independentemente do Lifecycle ter um observador anexado.
• O LifecycleRegistry agora vai limpar os observadores quando alcançarem o estado DESTROYED.

Versão 2.5.0-rc02

15 de junho de 2022

Lançamento de androidx.lifecycle:lifecycle-*:2.5.0-rc02. A versão 2.5.0-rc02 contém estas confirmações.

Correções de bugs

• A classe ViewModelProvider não vai mais falhar ao combinar versões anteriores de dependências compileOnly Lifecycle com a versão 2.5 ou mais recentes (I81a66, b/230454566).

Versão 2.5.0-rc01

11 de maio de 2022

Lançamento de androidx.lifecycle:lifecycle-*:2.5.0-rc01. A versão 2.5.0-rc01 contém estas confirmações.

Correções de bugs

• MediatorLiveData.addSource() agora gera uma NullPointerException quando recebe uma origem null em vez de propagar essa origem null para os observadores (Ibd0fb, b/123085232).

Versão 2.5.0-beta01

20 de abril de 2022

Lançamento de androidx.lifecycle:lifecycle-*:2.5.0-beta01. A versão 2.5.0-beta01 contém estas confirmações.

Mudanças na API

• Adicionados delegados de propriedade SavedStateHandle.saveable para usar nomes de propriedades como chaves a fim de manter o estado no SavedStateHandle (I8bb86, b/225014345).

Correções de bugs

• Foi corrigido um problema em que aninhar um NavHost em outro NavHost em uma guia de navegação inferior não principal causava uma IllegalStateException ao usar várias backstacks (I11bd5, b/228865698).

Versão 2.5.0-alpha06

6 de abril de 2022

Lançamento de androidx.lifecycle:lifecycle-*:2.5.0-alpha06. A versão 2.5.0-alpha06 contém estas confirmações.

Novos recursos

• A sobrecarga experimental MutableState foi adicionada ao SavedStateHandle.saveable para paridade com rememberSaveable (I38cfe, b/224565154).

Mudanças na API

• CreationExtras agora é abstrato em vez de selado (Ib8a7a).

Correções de bugs

• Um erro IllegalStateException: Already attached to lifecycleOwner causado por SavedStateHandleController foi corrigido (I7ea47, b/215406268).

Versão 2.5.0-alpha05

23 de março de 2022

Lançamento de androidx.lifecycle:lifecycle-*:2.5.0-alpha05. A versão 2.5.0-alpha05 contém estas confirmações.

Novos recursos

• O módulo lifecycle-viewmodel-compose agora fornece a SavedStateHandleSaver, uma API experimental que garante que os valores em um SavedStateHandle sejam integrados corretamente com o mesmo estado de instância salvo que o rememberSaveable usa (Ia88b7, b/195689777).

Mudanças na API

• Correção de um problema de compatibilidade com o Lifecycle 2.3 e versões mais recentes em Java (I52c8a, b/219545060).

Correções de bugs

• A SavedStateViewFactory agora oferece suporte ao uso de CreationExtras mesmo quando inicializada com um SavedStateRegistryOwner. Se extras forem fornecidos, os argumentos inicializados serão ignorados (I6c43b, b/224844583).

Versão 2.5.0-alpha04

9 de março de 2022

Lançamento de androidx.lifecycle:lifecycle-*:2.5.0-alpha04. A versão 2.5.0-alpha04 contém estas confirmações.

Mudanças na API

• O parâmetro SavedStateHandle agora oferece uma API getStateFlow() que retorna um StateFlow de Kotlin para monitorar mudanças de valor como uma alternativa ao uso de LiveData (Iad3ab, b/178037961).

Versão 2.5.0-alpha03

23 de fevereiro de 2022

Lançamento de androidx.lifecycle:lifecycle-*:2.5.0-alpha03. A versão 2.5.0-alpha03 contém estas confirmações.

Novos recursos

• Adicionadas uma API addCloseable() e uma nova sobrecarga de construtor que permite adicionar um ou mais objetos Closeable ao ViewModel que são fechados quando o ViewModel é apagado, sem exigir trabalhos manuais em onCleared() (I55ea0).
• lifecycle-viewmodel agora fornece uma InitializerViewModelFactory que permite adicionar a lambda para processar classes ViewModel particulares, usando CreationExtras como a fonte de dados principal (If58fc, b/216687549).
• lifecycle-viewmodel-compose agora oferece uma API viewModel() que usa uma fábrica de lambdas para criar uma instância do ViewModel sem exigir a criação de uma ViewModelProvider.Factory personalizada (I97fbb, b/216688927).

Mudanças na API

• Agora você pode criar um ViewModel com CreationExtras usando lifecycle-viewmodel-compose (I08887, b/216688927).

Mudanças de comportamento

• A tentativa de mover o Lifecycle.State do INITIALIZED para o DESTROYED agora sempre gerará uma IllegalStateException, independentemente de Lifecycle ter um observador anexado (I7c390, b/177924329)
• LifecycleRegistry agora vai limpar os observadores quando alcançarem o estado DESTROYED (I4f8dd, b/142925860).

Versão 2.5.0-alpha02

9 de fevereiro de 2022

Lançamento de androidx.lifecycle:lifecycle-*:2.5.0-alpha02. A versão 2.5.0-alpha02 contém estas confirmações.

Mudanças na API

• As classes SavedStateHandle e SavedStateViewModelFactory foram convertidas para Kotlin. Isso melhorou a nulidade do genérico nas duas (Ib6ce2, b/216168263, I9647a, b/177667711).
• O parâmetro switchMap da função LiveData agora pode ter uma saída anulável (I40396, b/132923666).
• As extensões LiveData -ktx agora são anotadas com @CheckResult para garantir que o resultado seja usado ao chamar essas funções (Ia0f05, b/207325134).

Mudanças de comportamento

• A SavedStateHandle agora armazena corretamente o defaultValue quando não há valor para a chave especificada (I1c6ce, b/178510877).

Correções de bugs

• No Lifecycle 2.4.1: atualização de lifecycle-process para depender de Startup 1.1.1, garantindo que as correções que impedem a classe ProcessLifecycleInitializer de gerar uma StartupException fiquem disponíveis por padrão (Ib01df, b/216490724).
• Agora, há uma mensagem de erro aprimorada quando as classes AndroidViewModel personalizadas têm parâmetros na ordem incorreta e tentam criar um ViewModel (I340f7, b/177667711).
• Agora, você pode criar um modelo de visualização com CreationExtras usando o AndroidViewModelFactory sem definir um aplicativo (I6ebef, b/217271656).

Versão 2.5.0-alpha01

26 de janeiro de 2022

Lançamento de androidx.lifecycle:lifecycle-*:2.5.0-alpha01. A versão 2.5.0-alpha01 contém estas confirmações.

ViewModel CreationExtras

Com esta versão, estamos estabelecendo as bases para reestruturar a forma como um ViewModel é construído. Em vez de um conjunto rígido de subclasses de ViewModelProvider.Factory que adicionam outras funcionalidades (permitindo um parâmetro de construtor Application via AndroidViewModelFactory e um parâmetro de construtor SavedStateHandle via SavedStateViewModelFactory e AbstractSavedStateViewModelFactory etc.), estamos migrando para um modelo de fábricas sem estado que dependem de um novo conceito, CreationExtras (Ia7343, b/188691010, b/188541057).

Com essa mudança, ViewModelProvider não faz mais chamadas diretas ao método create(Class<T>) anterior da ViewModelProvider.Factory. Em vez disso, ele chama uma nova sobrecarga de create: create(Class<T>, CreationExtras). Isso significa que todas as implementações diretas da instância ViewModelProvider.Factory agora têm acesso a cada um dos novos CreationExtras:

• ViewModelProvider.NewInstanceFactory.VIEW_MODEL_KEY: esta String fornece acesso à chave personalizada que você transmitiu para ViewModelProvider.get().
• ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY fornece acesso à classe Application.
• SavedStateHandleSupport.SAVED_STATE_REGISTRY_OWNER_KEY fornece acesso ao SavedStateRegistryOwner usado para construir esse ViewModel.
• SavedStateHandleSupport.VIEW_MODEL_STORE_OWNER_KEY fornece acesso ao ViewModelStoreOwner usado para construir esse ViewModel.
• SavedStateHandleSupport.DEFAULT_ARGS_KEY fornece acesso ao Bundle de argumentos que precisam ser usados para construir um SavedStateHandle.

Esses extras são fornecidos por padrão ao usar a Activity 1.5.0-alpha01, o Fragment 1.5.0-alpha01 e a Navigation 2.5.0-alpha01. Se você usar uma versão anterior dessas bibliotecas, a classe CreationExtras fica vazia. Todas as subclasses já existentes de ViewModelProvider.Factory foram reescritas para oferecer suporte ao caminho de criação legado usado pelas versões anteriores dessas bibliotecas e pela CreationExtras, que vai ser usada no futuro.

A classe CreationExtras permite que você construa uma ViewModelProvider.Factory que transmite apenas as informações necessárias a cada ViewModel sem depender de uma hierarquia restrita de subclasses de fábrica:

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 a função de extensão createSavedStateHandle() do Kotlin em CreationExtras de SavedStateHandleSupport para criar um SavedStateHandle somente para o ViewModel que precisa dele (Ia6654, b/188541057).

A classe CreationExtras personalizada pode ser fornecida substituindo o getDefaultViewModelCreationExtras() na sua ComponentActivity ou Fragment, tornando-as disponíveis para o ViewModelProvider.Factory personalizado como uma forma integrada de injeção. Esses extras são disponibilizados automaticamente para sua fábrica quando usados diretamente com ViewModelProvider ou ao usar as extensões de propriedade Kotlin by viewModels() e by activityViewModels() (I79f2b, b/207012584, b/207012585, b/207012490).

Correções de bugs

• Corrigido um problema em que o valor padrão fornecido para um SavedStateHandle reaparecia após a interrupção e a recriação do processo, mesmo que fosse especificamente removido do SavedStateHandle. Como consequência, SavedStateHandle não mescla mais os valores padrão e restaurados, usando apenas os valores restaurados como a fonte da verdade (I53a4b).

Versão 2.4

Versão 2.4.1

9 de fevereiro de 2022

Lançamento de androidx.lifecycle:lifecycle-*:2.4.1. A versão 2.4.1 contém estas confirmações.

Correções de bugs

• Backport do Lifecycle 2.5.0-alpha01: correção de um problema em que o valor padrão fornecido a uma SavedStateHandle reaparecia após a interrupção e recriação do processo, mesmo que especificamente removido da SavedStateHandle. Como consequência, SavedStateHandle não mescla mais os valores padrão e restaurados, usando apenas os valores restaurados como a fonte da verdade (I53a4b).
• lifecycle-process agora depende do Androidx Startup 1.1.1, que corrigiu a regressão quando o uso da classe ProcessLifecycleInitializer causava uma StartupException (b/216490724).

Versão 2.4.0

27 de outubro de 2021

Lançamento de androidx.lifecycle:lifecycle-*:2.4.0. A versão 2.4.0 contém estas confirmações.

Mudanças importantes desde a versão 2.3.0

• O uso de @OnLifecycleEvent foi descontinuado. Use o LifecycleEventObserver ou o DefaultLifecycleObserver
• A biblioteca androidx.lifecycle:lifecycle-viewmodel-compose foi adicionada. Ela fornece o viewModel() que pode ser composto e o LocalViewModelStoreOwner.
  • Alteração interruptiva de origem: o ViewModelProvider foi reescrito em Kotlin. O método ViewModelProvider.Factory.create não permite mais o uso de genéricos anuláveis.
• Uma nova API de corrotinas foi adicionada a androidx.lifecycle:lifecycle-runtime-ktx:
• Lifecycle.repeatOnLifecycle, API que executa um bloco de código em uma corrotina quando o ciclo de vida fica em pelo menos um determinado estado. O bloco será cancelado e reiniciado à medida que o ciclo de vida entrar e sair do estado de destino.
• Flow.flowWithLifecycle, API que emite valores do fluxo upstream quando o ciclo de vida está pelo menos em um determinado estado.
• O DefaultLifecycleObserver foi movido de lifecycle.lifecycle-common-java8 para lifecycle.lifecycle-common. O lifecycle.lifecycle-common-java8 não oferece mais nenhuma funcionalidade extra em relação a lifecycle.lifecycle-common. Portanto, a dependência dele pode ser substituída por lifecycle.lifecycle-common
• A API que não é de corrotinas do lifecycle-viewmodel-ktx foi movida para o módulo lifecycle-viewmodel.

• O lifecycle-process agora usa androidx.startup para inicializar o ProcessLifecycleOwner.

  Anteriormente, isso era feito pelo androidx.lifecycle.ProcessLifecycleOwnerInitializer.

  Se você usava tools:node="remove", a classe ContentProvider que era usada para inicializar o ciclo de vida do processo, será necessário fazer o seguinte:

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

  (ou)

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

Versão 2.4.0-rc01

29 de setembro de 2021

Lançamento de androidx.lifecycle:lifecycle-*:2.4.0-rc01 sem alterações do Lifecycle 2.4.0-beta01. A versão 2.4.0-rc01 contém estas confirmações.

Versão 2.4.0-beta01

15 de setembro de 2021

Lançamento de androidx.lifecycle:lifecycle-*:2.4.0-beta01. A versão 2.4.0-beta01 contém estas confirmações.

Mudanças na API

• O uso de @OnLifecycleEvent foi descontinuado. Use a interface LifecycleEventObserver ou a DefaultLifecycleObserver (I5a8fa).
• O DefaultLifecycleObserver foi movido de androidx.lifecycle.lifecycle-common-java8 para androidx.lifecycle.lifecycle-common. O androidx.lifecycle.lifecycle-common-java8 não oferece mais nenhuma funcionalidade extra em relação a androidx.lifecycle.lifecycle-common. Portanto, a dependência dele pode ser substituída por androidx.lifecycle.lifecycle-common (I021aa).
• A API que não é de corrotinas do lifecycle-viewmodel-ktx foi movida para o módulo lifecycle-viewmodel (I6d5b2).

Contribuição externa

• Agradecemos a dmitrilc (link em inglês) por corrigir um erro de digitação na documentação do ViewModel (#221).

Versão 2.4.0-alpha03

4 de agosto de 2021

Lançamento de androidx.lifecycle:lifecycle-*:2.4.0-alpha03. A versão 2.4.0-alpha03 contém estas confirmações.

Mudanças na API

• Alteração interruptiva de origem: o ViewModelProvider foi reescrito em Kotlin. O método ViewModelProvider.Factory.create não permite mais o uso de genéricos anuláveis. (I9b9f6).

Mudanças de comportamento

• O Lifecycle.repeatOnLifecycle: block agora sempre é invocado em série ao repetir a execução (Ibab33).

Contribuição externa

• Agradecemos chao2zhang por corrigir os snippets de código na documentação do repeatOnLifecycle (205).

Versão 2.4.0-alpha02

16 de junho de 2021

Lançamento de androidx.lifecycle:lifecycle-*:2.4.0-alpha02. A versão 2.4.0-alpha02 contém estas confirmações.

Novos recursos

• Uma nova verificação de lint RepeatOnLifecycleWrongUsage para lifecycle-runtime-ktx que detecta quando repeateOnLifecycle é usado incorretamente em onStart() ou onResume() foi adicionada (706078, b/187887400).

Mudanças na API

• A API LifecycleOwner.addRepeatingJob foi removida e substituída por Lifecycle.repeatOnLifecycle, que respeita a simultaneidade estruturada e é mais fácil de entender (I4a3a8).
• O ProcessLifecycleInitializer agora é público para que possa ser usado como dependência por outros androidx.startup.Initializers (I94c31).

Correções de bugs

• Correção de um problema com a verificação de lint NullSafeMutableLiveData quando o campo tem modificadores (147 (link em inglês), b/183696616).
• Outro problema com a verificação de lint NullSafeMutableLiveData ao usar generalizações foi corrigido (161 (link em inglês), b/184830263).

Contribuição externa

• Agradecemos a maxsav (link em inglês) por melhorar a verificação de lint NullSafeMutableLiveData (147 (link em inglês), b/183696616).
• Agradecemos a kozaxinan (link em inglês) por melhorar a verificação de lint NullSafeMutableLiveData (161, b/184830263).

Versão 2.4.0-alpha01

24 de março de 2021

Lançamento de androidx.lifecycle:lifecycle-*:2.4.0-alpha01. A versão 2.4.0-alpha01 contém estas confirmações.

Mudanças de comportamento

• O lifecycle-process agora usa androidx.startup para inicializar o ProcessLifecycleOwner.

  Anteriormente, isso era feito pelo androidx.lifecycle.ProcessLifecycleOwnerInitializer.

  Se você usava tools:node="remove", a classe ContentProvider que era usada para inicializar o ciclo de vida do processo, será necessário fazer o seguinte:

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

  (ou)

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

Mudanças na API

• Uma nova API Flow.flowWithLifecycle que emite valores do fluxo upstream quando o ciclo de vida fica pelo menos em um determinado estado usando a API Lifecycle.repeatOnLifecycle. Essa é uma alternativa à nova API LifecycleOwner.addRepeatinJob (I0f4cd).

Correções de bugs

• No Lifecycle 2.3.1: a regra de lint NonNullableMutableLiveData agora pode diferenciar adequadamente entre variáveis de campo com diferentes valores de nulidade (b/169249668).

Lifecycle Viewmodel Compose versão 1.0.0

Versão 1.0.0-alpha07

16 de junho de 2021

Lançamento de androidx.lifecycle:lifecycle-viewmodel-compose:1.0.0-alpha07. A versão 1.0.0-alpha07 contém estas confirmações.

Alterações interruptivas da API

• viewModel() agora usa um ViewModelStoreOwner opcional, facilitando o trabalho com proprietários diferentes de LocalViewModelStoreOwner. Por exemplo, agora você pode usar viewModel(navBackStackEntry) para extrair um ViewModel associado a um gráfico de navegação específico (I2628d, b/188693123).

Observação: essa é uma alteração interruptiva binária. É necessário atualizar para o Hilt-Navigation-Compose 1.0.0-alpha03 e o Navigation Compose 2.4.0-alpha03. Essa pode ser uma alteração interruptiva de origem se você não especificar key = ao usar viewModel(key, factory). Use argumentos nomeados: viewModel(key = key, factory = factory).

Versão 1.0.0-alpha06

2 de junho de 2021

Lançamento de androidx.lifecycle:lifecycle-viewmodel-compose:1.0.0-alpha06. A versão 1.0.0-alpha06 contém estas confirmações.

Atualizada para ser compatível com a versão 1.0.0-beta08 do Compose.

Versão 1.0.0-alpha05

18 de maio de 2021

Lançamento de androidx.lifecycle:lifecycle-viewmodel-compose:1.0.0-alpha05. A versão 1.0.0-alpha05 contém estas confirmações.

Novos recursos

• Atualizada para ser compatível com a versão 1.0.0-beta07 do Compose.

Correções de bugs

• Os arquivos AndroidManifest de ui-test-manifest e ui-tooling-data agora são compatíveis com o Android 12 (I6f9de, b/184718994).

Versão 1.0.0-alpha04

7 de abril de 2021

Lançamento de androidx.lifecycle:lifecycle-viewmodel-compose:1.0.0-alpha04. A versão 1.0.0-alpha04 contém estas confirmações.

Mudanças na dependência

• Essa versão permite que androidx.hilt:hilt-navigation-compose e androidx.navigation:navigation-compose sincronizem dependências em androidx.compose.compiler:compiler:1.0.0-beta04 e androidx.compose.runtime:runtime:1.0.0-beta04. Para a versão 1.0.0, tem que haver uma correspondência entre o compilador e o ambiente de execução.

Versão 1.0.0-alpha03

10 de março de 2021

Lançamento de androidx.lifecycle:lifecycle-viewmodel-compose:1.0.0-alpha03. A versão 1.0.0-alpha03 contém estas confirmações.

Mudanças na API

• LocalViewModelStoreOwner.current agora retorna um ViewModelStoreOwner anulável para determinar melhor se um ViewModelStoreOwner está disponível na composição atual. As APIs que exigem um ViewModelStoreOwner, como viewModel() e NavHost, ainda geram uma exceção se um ViewModelStoreOwner não está definido (Idf39a).

Lifecycle-Viewmodel-Compose: versão 1.0.0-alpha02

24 de fevereiro de 2021

Lançamento de androidx.lifecycle:lifecycle-viewmodel-compose:1.0.0-alpha02. A versão 1.0.0-alpha02 contém estas confirmações.

Mudanças na API

• LocalViewModelStoreOwner agora tem uma função provides que pode ser usada com CompositionLocalProvider, substituindo a API asProvidableCompositionLocal() (I45d24).

Observação: o Lifecycle ViewModel Compose 1.0.0-alpha02 só é compatível com o Compose 1.0.0-beta01.

Lifecycle-Viewmodel-Compose: versão 1.0.0-alpha01

10 de fevereiro de 2021

Lançamento de androidx.lifecycle:lifecycle-viewmodel-compose:1.0.0-alpha01. A versão 1.0.0-alpha01 contém estas confirmações.

Novos recursos

• A função de composição viewModel() e o LocalViewModelStoreOwner foram movidos de androidx.compose.ui.viewinterop para este artefato no pacote androidx.lifecycle.viewmodel.compose (I7a374).

Observação: o Lifecycle ViewModel Compose 1.0.0-alpha01 é compatível apenas com o Compose 1.0.0-alpha12.

Versão 2.3.1

Lifecycle versão 2.3.1

24 de março de 2021

Lançamento de androidx.lifecycle:lifecycle-*:2.3.1. A versão 2.3.1 contém estas confirmações.

Correções de bugs

• A regra de lint NonNullableMutableLiveData agora pode diferenciar corretamente entre variáveis de campo com diferentes valores de nulidade (b/169249668).

Versão 2.3.0

Versão 2.3.0

10 de fevereiro de 2021

Lançamento de androidx.lifecycle:lifecycle-*:2.3.0. A versão 2.3.0 contém estas confirmações.

Principais mudanças desde a versão 2.2.0

• Suporte de SavedStateHandle aclasses não comparáveis: SavedStateHandle agora oferece suporte a serialização lenta, permitindo chamar setSavedStateProvider() para determinada chave, fornecendo um SavedStateProvider que receberá um callback para saveState() quando for solicitado que o SavedStateHandle salve o estado dele. Consulte Salvar classes não comparáveis.
• Aplicação do comportamento do ciclo de vida:
  • O LifecycleRegistry agora aplica o DESTROYED como um estado terminal.
  • LifecycleRegistry agora verifica se os métodos são chamados na linha de execução principal. Isso sempre foi um requisito para ciclos de vida de atividades, fragmentos etc. A adição de observadores de linhas de execução não principais gerava dificuldade para capturar falhas durante a execução. Para objetos LifecycleRegistry que pertencem aos seus componentes, você pode desativar explicitamente as verificações usando LifecycleRegistry.createUnsafe(...). Mas é necessário garantir que haja uma sincronização adequada quando LifecycleRegistry é acessado de diferentes linhas de execução.
• Auxiliadores de evento e estado do ciclo de vida: foram adicionados métodos auxiliares estáticos de downFrom(State), downTo(State), upFrom(State), upTo(State) a Lifecycle.Event para gerar o Event com um State e uma direção de transição. O método getTargetState() que fornece o State para o qual o Lifecycle mudará diretamente após o Event foi adicionado.
• withStateAtLeast: foram adicionadas APIs Lifecycle.withStateAtLeast que aguardam um estado de ciclo de vida e executam um bloco de código não suspenso de forma síncrona no ponto de mudança de estado, depois são retomadas com o resultado. Essas APIs são diferentes dos métodos when* existentes, porque não permitem a execução do código de suspensão e não empregam um agente personalizado (aosp/1326081).
• APIs de ViewTree: as novas APIs ViewTreeLifecycleOwner.get(View) e ViewTreeViewModelStoreOwner.get(View) permitem que você extraia, respectivamente, o LifecycleOwner e o ViewModelStoreOwner contidos de uma instância View. É necessário fazer upgrade para Activity 1.2.0, Fragment 1.3.0 e AppCompat 1.3.0-alpha01 ou versões mais recentes para que o preenchimento seja feito de forma correta. As extensões Kotlin findViewTreeLifecycleOwner e findViewTreeViewModelStoreOwner estão disponíveis em lifecycle-runtime-ktx e lifecycle-viewmodel-ktx, respectivamente.
• Descontinuação da extensão Kotlin LiveData.observe(): a extensão Kotlin LiveData.observe() necessária para usar a sintaxe lambda foi descontinuada, porque ela não é necessária ao usar o Kotlin 1.4.

Versão 2.3.0-rc01

16 de dezembro de 2020

Lançamento de androidx.lifecycle:lifecycle-*:2.3.0-rc01. A versão 2.3.0-rc01 contém estas confirmações.

Correções de bugs

• O método keys() de SavedStateHandle agora é consistente antes e depois de o estado ser salvo. Agora, ele inclui chaves usadas anteriormente com setSavedStateProvider(), além das chaves usadas com set() e getLiveData() (aosp/1517919, b/174713653).

Contribuição externa

• As APIs para suspender corrotinas que reconhecem o ciclo de vida agora processam melhor as chamadas para yield(). Agradecemos a Nicklas Ansman Giertz (aosp/1430830, b/168777346).

Versão 2.3.0-beta01

1º de outubro de 2020

Lançamento de androidx.lifecycle:lifecycle-*:2.3.0-beta01. A versão 2.3.0-beta01 contém estas confirmações.

Mudanças na API

• A extensão Kotlin LiveData.observe() necessária para usar a sintaxe lambda teve o uso suspenso, porque ela não é necessária ao usar o Kotlin 1.4 (I40d3f).

Correções de bugs

• Atualização do AndroidX para usar o Kotlin 1.4 (Id6471, b/165307851, b/165300826).

Mudanças na documentação

• O builder liveData e os documentos asLiveData() foram atualizados para incluir detalhes sobre como mudar os valores de tempo limite fornecidos (aosp/1122324).

Versão 2.3.0-alpha07

19 de agosto de 2020

Lançamento de androidx.lifecycle:lifecycle-*:2.3.0-alpha07. A versão 2.3.0-alpha07 contém estas confirmações.

Correções de bugs

• Correção de uma falha na verificação de lint NullSafeMutableLiveData (aosp/1395367).

Versão 2.3.0-alpha06

22 de julho de 2020

Lançamento de androidx.lifecycle:lifecycle-*:2.3.0-alpha06. A versão 2.3.0-alpha06 contém estas confirmações.

Novos recursos

• Adição de métodos auxiliares estáticos de downFrom(State), downTo(State), upFrom(State), upTo(State) a Lifecycle.Event para gerar o Event com um State e uma direção de transição. O método getTargetState() que fornece o State para qual o Lifecycle mudará diretamente depois do Event foi adicionado (I00887).
• Adição de APIs Lifecycle.withStateAtLeast que aguardam um estado de ciclo de vida e executam um bloco de código não suspenso de forma síncrona no ponto de mudança de estado, depois retomam com o resultado. Essas APIs são diferentes dos métodos when* existentes, porque não permitem a execução do código de suspensão e não empregam um agente personalizado (aosp/1326081).

Mudanças de comportamento

• O LifecycleRegistry agora aplica o DESTROYED como um estado terminal. (I00887).
• LifecycleRegistry agora verifica se os métodos são chamados na linha de execução principal. Isso sempre foi um requisito para ciclos de vida de atividades, fragmentos etc. A adição de observadores de linhas de execução não principais gerava dificuldade para capturar falhas durante a execução. Para objetos LifecycleRegistry que pertencem aos seus componentes, você pode desativar explicitamente as verificações com o uso de LifecycleRegistry.createUnsafe(...). Mas é necessário garantir que haja uma sincronização adequada quando esse LifecycleRegistry é acessado de diferentes linhas de execução (Ie7280, b/137392809).

Correções de bugs

• Correção de uma falha em NullSafeMutableLiveData (b/159987480).
• Uma ObsoleteLintCustomCheck para verificações de lint empacotadas com lifecycle-livedata-core-ktx e especificamente com NullSafeMutableLiveData foi corrigida (b/158699265).

Versão 2.3.0-alpha05

24 de junho de 2020

Lançamento de androidx.lifecycle:lifecycle-*:2.3.0-alpha05. A versão 2.3.0-alpha05 contém estas confirmações.

Correções de bugs

• LiveData agora lida melhor com casos reentrantes, evitando chamadas duplicadas para onActive() ou onInactive() (b/157840298).
• Corrigido um problema em que as verificações de lint não eram executadas ao usar o Android Studio 4.1 Canary 6 ou versão mais recente (aosp/1331903).

Versão 2.3.0-alpha04

10 de junho de 2020

Lançamento de androidx.lifecycle:lifecycle-*:2.3.0-alpha04. A versão 2.3.0-alpha04 contém estas confirmações.

Correções de bugs

• Correção de uma falha na verificação de lint NonNullableMutableLiveData (b/157294666).
• A verificação de lint NonNullableMutableLiveData agora abrange um número significativamente maior de casos em que o valor null era definido em um MutableLiveData com um parâmetro de tipo não nulo (b/156002218).

Versão 2.3.0-alpha03

20 de maio de 2020

Lançamento de androidx.lifecycle:lifecycle-*:2.3.0-alpha03. A versão 2.3.0-alpha03 contém estas confirmações.

Novos recursos

• SavedStateHandle agora oferece suporte a serialização lenta, permitindo que você chame setSavedStateProvider() para determinada chave, fornecendo um SavedStateProvider que receberá um callback para saveState() quando for solicitado que SavedStateHandle salve o estado dele (b/155106862).
• Uma nova API ViewTreeViewModelStoreOwner.get(View) permite que você extraia a interface ViewModelStoreOwner contida com uma instância View. É necessário fazer upgrade para Activity 1.2.0-alpha05, Fragment 1.3.0-alpha05 e AppCompat 1.3.0-alpha01 para preencher corretamente. Uma extensão Kotlin findViewModelStoreOwner() foi adicionada a lifecycle-viewmodel-ktx (aosp/1295522).

Correções de bugs

• Um problema que fazia com que as verificações de Lint MutableLiveData lançadas no Lifecycle 2.3.0-alpha01 fossem publicadas usando o artefato lifecycle-livedata-core-ktx foi corrigido (b/155323109).

Versão 2.3.0-alpha02

29 de abril de 2020

Lançamento de androidx.lifecycle:lifecycle-*:2.3.0-alpha02. A versão 2.3.0-alpha02 contém estas confirmações.

Mudanças na API

• SavedStateViewModelFactory agora permite que você transmita um Application nulo ao construtor para históricos de consulta melhores em que um deles não está disponível rapidamente, e o suporte para AndroidViewModel não é necessário (aosp/1285740).

Correções de bugs

• Melhor desempenho de inicialização a frio, evitando falhas na verificação de classe na API 28 e em dispositivos anteriores (aosp/1282118).

Versão 2.3.0-alpha01

4 de março de 2020

Lançamento de androidx.lifecycle:lifecycle-*:2.3.0-alpha01. A versão 2.3.0-alpha01 contém estas confirmações.

Novos recursos

• Uma nova API ViewTreeLifecycleOwner.get(View) permite que você extraia a interface LifecycleOwner contida com uma instância View. É necessário fazer upgrade para Activity 1.2.0-alpha01 e Fragment 1.3.0-alpha01 para preencher corretamente. Uma extensão findViewTreeLifecycleOwner do Kotlin está disponível em lifecycle-runtime-ktx (aosp/1182361, aosp/1182956).
• Adição de uma nova verificação do Lint que avisa quando você define um valor null em um MutableLiveData definido no Kotlin como não nulo. Isso está disponível ao usar os artefatos livedata-core-ktx ou livedata-ktx (aosp/1154723, aosp/1159092).
• Um novo artefato lifecycle-runtime-testing está disponível e fornece um TestLifecycleOwner que implementa LifecycleOwner e fornece um Lifecycle seguro e mutável da linha de execução (aosp/1242438).

Correções de bugs

• O artefato lifecycle-runtime agora tem um nome de pacote exclusivo (aosp/1187196).

Observação: de acordo com as notas da versão do Lifecycle 2.2.0, o artefato lifecycle-extensions não será mais publicado.

Versão 2.2.0

ViewModel-Savedstate Versão 2.2.0

5 de fevereiro de 2020

Lançamento de androidx.lifecycle:lifecycle-viewmodel-savedstate:2.2.0. A versão 2.2.0 contém estas confirmações.

O Lifecycle ViewModel SavedState agora compartilha a mesma versão de outros artefatos do Lifecycle. O comportamento de 2.2.0 é idêntico ao comportamento de 1.0.0.

Versão 2.2.0

22 de janeiro de 2020

androidx.lifecycle:lifecycle-*:2.2.0 é lançado. A versão 2.2.0 contém estas confirmações.

Mudanças importantes desde a versão 2.1.0

• Integração com corrotinas do Lifecycle: o novo artefato lifecycle-runtime-ktx acrescenta integração entre as corrotinas do Lifecycle e do Kotlin. O lifecycle-livedata-ktx também foi expandido para aproveitar as corrotinas. Consulte Usar corrotinas do Kotlin com componentes de arquitetura para saber mais.
• Descontinuação do ViewModelProviders.of(): o uso do ViewModelProviders.of() foi descontinuado. Você pode transmitir um Fragment ou FragmentActivity ao novo construtor ViewModelProvider(ViewModelStoreOwner) para ter a mesma funcionalidade quando usar o Fragment 1.2.0.
• Descontinuação do artefato lifecycle-extensions: com a descontinuação do ViewModelProviders.of() descrita acima, esta versão marca a descontinuação da última API em lifecycle-extensions, e esse artefato agora será considerado completamente descontinuado. É altamente recomendável depender dos artefatos específicos necessários do Lifecycle (como lifecycle-service, se você estiver usando LifecycleService, e lifecycle-process, se você estiver usando ProcessLifecycleOwner) em vez de lifecycle-extensions, já que não haverá uma futura versão 2.3.0 de lifecycle-extensions.
• Processador de anotações incremental do Gradle: o processador de anotações do Lifecycle é incremental por padrão. Se o app tiver sido programado com a linguagem de programação Java 8, você pode usar DefautLifecycleObserver. Se ele tiver sido programado com a linguagem de programação Java 7, você pode usar LifecycleEventObserver.

Versão 2.2.0-rc03

4 de dezembro de 2019

androidx.lifecycle:lifecycle-*:2.2.0-rc03 é lançado. A versão 2.2.0-rc03 contém estas confirmações.

Correções de bugs

• Corrigida uma falha que ocorria quando um ViewModel simulado era armazenado em ViewModelStore e consultado com a fábrica padrão.
• Correção de um uso de Dispatchers.Main.immediate em launchWhenCreated e métodos semelhantes para serem chamados de maneira síncrona durante o evento de ciclo de vida correspondente (aosp/1156203).

Contribuições externas

• Agradecemos a Anders Järleberg por contribuir com a correção (aosp/1156203).
• Agradecemos a Vsevolod Tolstopyatov, da Jetbrains, por revisar uma implementação de execução in-line.

Mudanças na dependência

• As extensões do Lifecycle agora dependem do Fragment 1.2.0-rc03.

Versão 2.2.0-rc02

7 de novembro de 2019

androidx.lifecycle:lifecycle-*:2.2.0-rc02 é lançado. A versão 2.2.0-rc02 contém estas confirmações.

Correções de bugs

• Corrigido um bug na configuração do Proguard da biblioteca que afetava os dispositivos com a API 28 e mais recentes se a API de destino fosse anterior à 29 (b/142778206)

Versão 2.2.0-rc01

23 de outubro de 2019

Lançamento de androidx.lifecycle:lifecycle-*:2.2.0-rc01. A versão 2.2.0-rc01 contém estas confirmações.

Correções de bugs

• Foi corrigido um problema em que launchWhenCreated e métodos relacionados executavam um frame depois do método de ciclo de vida associado devido ao uso de Dispatchers.Main em vez de Dispatchers.Main.immediate (aosp/1145596).

Contribuições externas

• Agradecemos a Nicklas Ansman por contribuir com a correção (aosp/1145596).

Versão 2.2.0-beta01

9 de outubro de 2019

androidx.lifecycle:lifecycle-*:2.2.0-beta01 é lançado. A versão 2.2.0-beta01 contém estas confirmações.

Correções de bugs

• Foi corrigida uma regressão introduzida no Lifecycle 2.2.0-alpha05 na ordenação da classe ProcessLifecycleOwner e na movimentação da interface LifecycleOwner da atividade para iniciação e retomada em dispositivos Android 10 (aosp/1128132).
• Corrigida uma regressão introduzida no Lifecycle 2.2.0-alpha05 que causava uma NullPointerException ao usar a versão 2.0.0 ou 2.1.0 do lifecycle-process (b/141536990).

Versão 2.2.0-alpha05

18 de setembro de 2019

Lançamento de androidx.lifecycle:lifecycle-*:2.2.0-alpha05. A versão 2.2.0-alpha05 contém estas confirmações.

Correções de bugs

• Uma disputa no builder da corrotina livedata foi corrigida b/140249349.

Versão 2.2.0-alpha04

5 de setembro de 2019

Lançamento de androidx.lifecycle:lifecycle-*:2.2.0-alpha04. As confirmações incluídas nessa versão podem ser encontradas neste link.

Novos recursos

• lifecycleScope, whenCreated, whenStarted, whenResumed, viewModelScope e a implementação de liveData agora usam Dispatchers.Main.immediate em vez de Dispatchers.Main (b/139740492).

Contribuições externas

• Agradecemos a Nicklas Ansman por contribuir com a migração para Dispatchers.Main.immediate (aosp/1106073).

Versão 2.2.0-alpha03

7 de agosto de 2019

androidx.lifecycle:lifecycle-*:2.2.0-alpha03 é lançado. As confirmações incluídas nessa versão podem ser encontradas neste link.

Novos recursos

• Agora, as implementações de ViewModelStoreOwner têm a opção de implementar HasDefaultViewModelProviderFactory para oferecer um ViewModelProvider.Factory padrão. Isso foi feito para Activity1.1.0-alpha02, Fragment1.2.0-alpha02 e Navigation2.2.0-alpha01 (aosp/1092370, b/135716331).

Mudanças na API

• O uso de ViewModelProviders.of() foi descontinuado. Você pode transmitir um Fragment ou FragmentActivity ao novo construtor ViewModelProvider(ViewModelStoreOwner) para ter a mesma funcionalidade (aosp/1009889).

Versão 2.2.0-alpha02

2 de julho de 2019

Lançamento de androidx.lifecycle:*:2.2.0-alpha02. As confirmações incluídas nessa versão podem ser encontradas neste link.

Mudanças na API

• LiveDataScope.initialValue foi substituído por LiveDataScope.latestValue, que rastreará o valor atual emitido do bloco liveData.
• Uma nova sobrecarga foi adicionada ao builder liveData, que recebe o parâmetro timeout como o tipo Duration.

Versão 2.2.0-alpha01

7 de maio de 2019

Lançamento de androidx.lifecycle:*:2.2.0-alpha01. As confirmações incluídas nessa versão podem ser encontradas neste link.

Novos recursos

• Essa versão adiciona novos recursos para incluir suporte a corrotinas do Kotlin para Lifecycle e LiveData. A documentação detalhada sobre eles pode ser encontrada neste link.

ViewModel-SavedState Versão 1.0.0

Versão 1.0.0

22 de janeiro de 2020

Lançamento de androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0. A versão 1.0.0 contém essas confirmações (link em inglês).

Recursos importantes da versão 1.0.0

• Adição da nova classe SavedStateHandle. Ela permite que as classes ViewModel acessem e contribuam com o estado salvo. Esse objeto pode ser recebido no construtor da classe ViewModel, e as fábricas fornecidas por padrão por fragmentos e AppCompatActivity vão injetar SavedStateHandle automaticamente.
• Adição de AbstractSavedStateViewModelFactory. Ela permite que você crie fábricas personalizadas para ViewModel e forneça acesso a SavedStateHandle.

ViewModel-Savedstate Versão 1.0.0-rc03

4 de dezembro de 2019

Lançamento de androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-rc03. A versão 1.0.0-rc03 contém estas confirmações.

Mudanças na dependência

• O Lifecycle ViewModel SavedState agora depende do Lifecycle 2.2.0-rc03.

Viewmodel-Savedstate Versão 1.0.0-rc02

7 de novembro de 2019

Lançamento de androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-rc02. A versão 1.0.0-rc02 contém estas confirmações.

Mudanças na dependência

• Agora depende do lifecycle 2.2.0-rc02.

ViewModel-SavedState Versão 1.0.0-rc01

23 de outubro de 2019

Lançamento de androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-rc01 sem mudanças desde a versão 1.0.0-beta01. A versão 1.0.0-rc01 contém estas confirmações.

ViewModel-Savedstate Versão 1.0.0-beta01

9 de outubro de 2019

Lançamento de androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-beta01. A versão 1.0.0-beta01 contém estas confirmações.

Correções de bugs

• Corrigido um problema ao acessar um ViewModel de SavedState pela primeira vez em Activity.onActivityResult() que resultava em uma IllegalStateException (b/139093676).
• Uma IllegalStateException ao usar AbstractSavedStateViewModelFactory foi corrigida (b/141225984).

ViewModel-SavedState Versão 1.0.0-alpha05

18 de setembro de 2019

Lançamento de androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-alpha05. A versão 1.0.0-alpha05 contém estas confirmações.

Mudanças na API

• SavedStateViewModelFactory não estende mais AbstractSavedStateViewModelFactory, e SavedStateHandle é criado apenas para ViewModels que o solicitaram (aosp/1113593).

ViewModel-SavedState Versão 1.0.0-alpha03

7 de agosto de 2019

androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-alpha03 é lançado. As confirmações incluídas nessa versão podem ser encontradas neste link.

Mudanças importantes

• lifecycle-viewmodel-savedstate não depende mais de fragment, e os construtores SavedStateViewModelFactory(Fragment) e SavedStateViewModelFactory(FragmentActivity) relacionados foram removidos. Em vez disso, SavedStateViewModelFactory agora é a fábrica padrão para Activity 1.1.0-alpha02, Fragment 1.2.0-alpha02 e Navigation 2.2.0-alpha01. (b/135716331).

ViewModel-SavedState Versão 1.0.0-alpha02

2 de julho de 2019

Lançamento de androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-alpha02. As confirmações incluídas nessa versão podem ser encontradas neste link.

Novos recursos

• A sobrecarga SavedStateHandle.getLiveData(), que aceita um valor padrão, foi adicionada.

Mudanças na API

• SavedStateVMFactory foi renomeado como SavedStateViewModelFactory.
• AbstractSavedStateVMFactory foi renomeado como AbstractSavedStateViewModelFactory.

ViewModel-Savedstate Versão 1.0.0-alpha01

13 de março de 2019

Lançamento de androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-alpha01. O registro de confirmação completo dessa versão inicial pode ser encontrado neste link.

Novos recursos

• Agora ViewModels pode contribuir para o savedstate. Para isso, use a recém-introduzida fábrica do ViewModel, SavedStateVMFactory. Além disso, o ViewModel precisa ter um construtor que receba o objeto SavedStateHandle como parâmetro.

Versão 2.1.0

Mudanças importantes desde a versão 2.0.0

• O LifecycleEventObserver foi adicionado para os casos em que um stream de eventos do ciclo de vida é necessário. Trata-se de uma API pública, em vez de uma classe GenericLifecycleObserver oculta.
• Adicionadas extensões ktx para os métodos LiveData.observe e Transformations.*.
• Transformations.distinctUntilChanged, que cria um novo objeto LiveData que não emite um valor até que o valor LiveData de origem tenha sido alterado foi adicionado.
• Foi adicionado suporte à corrotina em ViewModels com o acréscimo da propriedade de extensão ViewModel.viewModelScope.

Versão 2.1.0

5 de setembro de 2019

Lançamento de androidx.lifecycle:lifecycle-*:2.1.0. As confirmações incluídas nessa versão podem ser encontradas neste link.

Versão 2.1.0-rc01

2 de julho de 2019

Lançamento de androidx.lifecycle:*:2.1.0-rc01 sem mudanças desde androidx.lifecycle:*:2.1.0-beta01. As confirmações incluídas nessa versão podem ser encontradas neste link.

Versão 2.1.0-beta01

7 de maio de 2019

Lançamento de androidx.lifecycle:*:2.1.0-beta01. As confirmações incluídas nessa versão podem ser encontradas neste link.

Novos recursos

• Lifecycles foram atualizados para a versão Beta. As APIs introduzidas em versões Alfas anteriores, como funções de extensão de liveData para transformações e observações, inicialização do ViewModel com delegação de propriedades, entre outras, estão estabilizadas e não vão mudar.

Versão 2.1.0-alpha04

3 de abril de 2019

Lançamento de androidx.lifecycle:*:2.1.0-alpha04. As confirmações incluídas nessa versão podem ser encontradas neste link.

Observação: lifecycle-viewmodel-ktx é incompatível com a Activity 1.0.0-alpha01 a 1.0.0-alpha05 e com o Fragment 1.1.0-alpha01 a 1.1.0-alpha05. Atualize para a Activity 1.0.0-alpha06 e para o Fragment 1.1.0-alpha06, respectivamente.

Mudanças na API

• Alteração interruptiva: a API relacionada a by viewModels() e a by activityViewModels() mudou para oferecer suporte direto a ViewModelStore, e não apenas a um ViewModelStoreOwner (aosp/932932, link em inglês)

Versão 2.1.0-alpha03

13 de março de 2019

Lançamento de androidx.lifecycle:*:2.1.0-alpha03. A lista completa de confirmações incluídas nessa versão pode ser encontrada neste link.

Mudanças na API

• ViewModelProvider.KeyedFactory foi removido. A segunda interface, além de ViewModelProvider.Factory, não combinou bem com novos recursos, como delegação de propriedades em Kotlin by viewmodels {} (aosp/914133, link em inglês)

Versão 2.1.0-alpha02

30 de janeiro de 2019

Lançamento de androidx.lifecycle 2.1.0-alpha02.

Mudanças na API

• Agora LifecycleRegistry contém um método setCurrentState() que substitui o método descontinuado setState() (aosp/880715, link em inglês)

Correções de bugs

• Foi corrigido um problema que fazia com que instâncias fictícias de ViewModel falhassem quando a classe ViewModelStore era liberada (b/122273087).

Versão 2.1.0-alpha01

17 de dezembro de 2018

Lançamento de androidx.lifecycle 2.1.0-alpha01.

Novos recursos

• O LifecycleEventObserver foi adicionado para os casos em que um stream de eventos do ciclo de vida é necessário. Trata-se de uma API pública, em vez de uma classe GenericLifecycleObserver oculta.
• Adicionadas extensões ktx para os métodos LiveData.observe e Transformations.*.
• O método Transformations.distinctUntilChanged foi adicionado. Ele cria um novo objeto LiveData que não emite valores até que o valor LiveData de origem mude.
• Adicionado suporte de corrotinas em ViewModels: a propriedade da extensão ViewModel.viewModelScope foi adicionada.
• Adicionada ViewModelProvider.KeyedFactory, uma fábrica para ViewModels que recebe key e Class no método create.

Versão 2.0.0

Versão 2.0.0

21 de setembro de 2018

A versão 2.0.0 foi lançada com uma correção de bug de 2.0.0-rc01 em ViewModel.

Correções de bugs

• Correção de uma regra Proguard do ViewModel que removia incorretamente os construtores. b/112230489

Versão 2.0.0-beta01

2 de julho de 2018

Correções de bugs

• A regra Proguard do LifecycleObserver foi corrigida para manter apenas implementações, e não subinterfaces b/71389427.
• As regras Proguard do ViewModel foram corrigidas para permitir ofuscação e redução.

Versões anteriores ao AndroidX

Para as seguintes versões do Lifecycle anteriores ao AndroidX, inclua estas dependências:

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

Versão 1.1.1

21 de março de 2018

Só uma pequena mudança: android.arch.core.util.Function foi movida de arch:runtime para arch:common. Isso possibilita o uso sem a dependência de execução, por exemplo, em paging:common abaixo.

lifecycle:common é uma dependência de lifecycle:runtime. Por esse motivo, essa mudança não afeta lifecycle:runtime diretamente, mas apenas os módulos que dependem diretamente de lifecycle:common, como, por exemplo, Paging.

Versão 1.1.0

22 de janeiro de 2018

Mudanças no empacotamento

Novas dependências muito menores agora estão disponíveis:

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

Observação: Lifecycle Extensions 1.0.0 (android.arch.lifecycle:extensions:1.0.0) não é compatível com livedata:1.1.0 ou viewmodel:1.1.0. Atualize para extensions:1.1.0, que inclui uma dependência transitiva de livedata:1.1.0 e viewmodel 1.1.0.

Observação: android.arch.lifecycle:reactivestreams:1.1.0 agora só depende de android.arch.lifecycle:livedata:1.1.0, não de todas as android.arch.lifecycle:extensions:1.1.0.

Mudanças na API

• Os LifecycleActivity e LifecycleFragment obsoletos foram descontinuados. Use FragmentActivity, AppCompatActivity ou ofereça suporte a Fragment.
• Adicionadas anotações @NonNull a ViewModelProviders e ViewModelStores
• O construtor ViewModelProviders foi descontinuado. Use os métodos estáticos dele diretamente.
• O uso de ViewModelProviders.DefaultFactory foi descontinuado. Use ViewModelProvider.AndroidViewModelFactory.
• Adicionado o método ViewModelProvider.AndroidViewModelFactory.getInstance(Application) estático para recuperar uma Factory estática adequada para criar instâncias ViewModel e AndroidViewModel.