Ciclo de vida
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,4 | - | - | 2.9.0-alpha01 |
lifecycle-viewmodel-compose | 2.8,4 | - | - | 2.9.0-alpha01 |
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:
Kotlin
Groovy
dependencies { def lifecycle_version = "2.8.4" 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.4" 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.4" 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.4" 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.
Consulte a documentação do Issue Tracker para saber mais.
Versão 2.8
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 noLiveData
(por exemplo, ao usartake(1)
). (I9c566).- A conclusão de
Lifecycle*Effect
agora é idempotente, ou seja, se oonStopOrDispose
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 paraSTARTED
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 docompileOnly
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 emcompose-runtime
, removendo a dependência comum decompose-ui
. O artefato do Android mantém ocompose-ui
para compatibilidade. (aosp/3079334, b/339562627).- A integração de
saveable
deViewModel
usando delegados de propriedade agora usa o nome da classe como parte da chave gerada automaticamente, evitando conflitos caso várias classes usem a mesmaSavedStateHandle
. (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 paralifecycle-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 APIsdropUnlessResumed
edropUnlessStarted
, que permitem soltar o clique ou outros eventos que ocorrem mesmo depois que aLifecycleOwner
está abaixo doLifecycle.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 eSupervisorJob()
ou substitua o padrão usando obackgroundScope
disponível emrunTest
. (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 usaAutoClosable
em vez deCloseable
. Agora, ele oferece suporte à adição de objetosAutoCloseable
com umkey
que permite os extrair usandogetCloseable()
.Chamar
LifecycleStartEffect
eLifecycleResumeEffect
sem uma chave agora é um erro, seguindo a mesma convenção da APIDisposableEffect
que essas APIs espelham.O uso de
LiveDataReactiveStreams.toPublisher(lifecycleOwner, liveData)
foi descontinuado e substituído porLiveData.toPublisher(lifecycleOwner)
.As extensões Kotlin
lifecycle-livedata-core-ktx
foram movidas para o módulolifecycle-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 paracommon
e oferece suporte a jvm e iOS, além do Android.lifecycle-runtime
move a maioria das APIs paracommon
e oferece suporte a jvm e iOS, além do Android.lifecycle-runtime-ktx
agora está vazio, com todas as APIs sendo movidas paralifecycle-runtime
.- O
lifecycle-runtime-compose
move todas as APIs paracommon
e envia um artefato do Android, correspondendo ao suporte multiplataforma deandroidx.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étodosViewModelProvider.create()
em vez de chamar diretamente o construtor. ViewModelProvider.NewInstanceFactory
eViewModelProvider.AndroidViewModelFactory
estão disponíveis apenas no Android.- Recomendamos que as fábricas personalizadas sejam estendidas do
ViewModelProvider.Factory
e usem o métodocreate
, que usa umCreationExtras
ou a DSLviewModelFactory
do Kotlin.
- Recomendamos que as fábricas personalizadas sejam estendidas do
- O uso de
ViewModelProvider
sem uma fábrica personalizada em plataformas não JVM vai resultar em umaUnsupportedOperationException
. 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 umEmptyCoroutineContext
nas plataformas em queDispatchers.Main
não estiver disponível (por exemplo, Linux).
Artefatos afetados:
lifecycle-viewmodel
move a maioria das APIs paracommon
e oferece suporte a jvm e iOS, além do Android.lifecycle-viewmodel-ktx
agora está vazio, com todas as APIs sendo movidas paralifecycle-viewmodel
.- O
lifecycle-viewmodel-compose
move todas as APIs paracommon
e envia um artefato do Android, correspondendo ao suporte multiplataforma deandroidx.compose
.
Mudanças de comportamento
InitializerViewModelFactory
(incluindo a função de builderviewModelFactory
) agora vai gerar umaIllegalArgumentException
se uminitializer
com o mesmoclazz: 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 delifecycle-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 deaddCloseable(String, AutoCloseable)
, depoisaddClosable(AutoCloseable)
e depoisonCleared()
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 paracommon
e envia um artefato Android, correspondendo ao suporte multiplataforma paraandroidx.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 paracommon
e envia um artefato Android, correspondendo ao suporte multiplataforma deandroidx.compose
. Para acomodar essa mudança, o métodoviewModel
combinável agora aceita umKClass
, além de umjava.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 eSupervisorJob()
ou substitua o padrão usando obackgroundScope
disponível emrunTest
. (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étodosViewModelProvider.create()
em vez de chamar diretamente o construtor. ViewModelProvider.NewInstanceFactory
eViewModelProvider.AndroidViewModelFactory
estão disponíveis apenas no Android.- Recomendamos que as fábricas personalizadas sejam estendidas do
ViewModelProvider.Factory
e usem o métodocreate
, que usa umCreationExtras
ou a DSLviewModelFactory
do Kotlin.
- Recomendamos que as fábricas personalizadas sejam estendidas do
- O uso de
ViewModelProvider
sem uma fábrica personalizada em plataformas não JVM vai resultar em umaUnsupportedOperationException
. 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 umEmptyCoroutineContext
nas plataformas em queDispatchers.Main
não estiver disponível (por exemplo, Linux).
Mudanças de comportamento
InitializerViewModelFactory
(incluindo a função de builderviewModelFactory
) agora vai gerar umaIllegalArgumentException
se uminitializer
com o mesmoclazz: KClass<VM : ViewModel>
já tiver sido adicionado (Ic3a36).
Correções de bugs
ViewModel.getCloseable
agora lida com chaves duplicadas: se okey
já tiver um recursoAutoCloseable
associado a ele, o recurso antigo será substituído e fechado imediatamente. (Ibeb67).- O acesso ao
viewModelScope
de umViewModel
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
edropUnlessStarted
foram adicionadas, o que permite soltar cliques ou outros eventos que ocorrem mesmo depois queLifecycleOwner
fica abaixo doLifecycle.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
eLifecycleRegistry
agora são enviadas em artefatos compatíveis com o Kotlin Multiplatform. (b/317249252).
Mudanças na API
- Chamar
LifecycleStartEffect
eLifecycleResumeEffect
sem uma chave agora é um erro, seguindo a mesma convenção da APIDisposableEffect
que essas APIs espelham. (Ib0e0c, b/323518079). ViewModel
agora usaAutoCloseable
em vez deCloseable
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 porLiveData.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
- O
ViewModel
agora oferece suporte à adição de objetosCloseable
com umkey
que permite os extrair usandogetCloseable()
(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ãosetCurrentState()
que garante que a mudança de estado e todos os callbacks deLifecycleObserver
sejam concluídos antes do retorno É importante ressaltar que, ao contrário da configuração direta da propriedadecurrentState
, ele não usarunBlocking
, o que o torna seguro em uma corrotina como a fornecida porrunTest
.- As extensões
LiveData
demap
eswitchMap
agora espelham o comportamento dedistinctUntilChanged
. Se oLiveData
tiver umvalue
definido, a funçãomap
/switchMap
será chamada imediatamente para preencher ovalue
daLiveData
retornada. Isso garante que o valor inicial seja definido como parte da primeira composição (quando usado comobserveAsState()
), mas não muda o comportamento de observação. As atualizações dos valores daLiveData
de origem ainda vão ser aplicadas apenas quando você começar a observar oLiveData
. - Esta versão corrige um problema em que o
SavedStateHandle
não restaurava corretamente as classesParcelable
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 sobreget
,getLiveData
egetStateFlow
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 umFlow
deLifecycle.Event
usando o método de extensãoLifecycle.asFlow()
. - Os usuários do Jetpack Compose agora podem usar
LifecycleEventEffect
para executar efeitos colaterais do Compose com base emLifecycle.Event
.
@Composable
fun HomeScreen(viewModel: HomeViewModel = viewModel()) {
LifecycleEventEffect(Lifecycle.Event.ON_RESUME) {
viewModel.refreshData()
}
// …
}
- Os usuários do Jetpack Compose podem usar
LifecycleStartEffect
eLifecycleResumeEffect
para processar pares de eventos, iniciados para interrompidos e retomados para pausados, respectivamente. Essa API espelha a encontrada emDisposableEffect
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 propriedadeLifecycle.currentStateFlow
, que retorna umStateFlow
em quevalue
é oLifecycle.State
atual. - Os usuários do Jetpack Compose podem usar a extensão
Lifecycle.currentStateAsState()
para expor diretamenteLifecycle.State
comoState
do Compose. Isso é equivalente (e uma alternativa mais curta) alifecycle.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 classesParcelable
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 sobreget
,getLiveData
egetStateFlow
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
eLifecycleResumeEffect
agora descartam e recriam corretamente o bloco de efeito se oLifecycleOwner
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 doLifecycle.State
doTestLifecycleOwner
usando o campocurrentState
quando dentro de uma corrotina. A verificação de lint agora sugere a suspensãosetCurrentState
, que permite definir oLifecycle.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 deLiveData
na chamada inicial e em uma chamada seguinte impedia que a instânciaLiveData
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ãosetCurrentState()
para oferecer aos usuários a opção de usarTestLifecycleOwner
em uma corrotina, como a fornecida porrunTest
. (I329de, b/259344129).
Mudanças na API
- Todos os arquivos dos módulos
lifecycle-livedata-ktx
foram movidos para o módulolifecycle-livedata
principal. (I10c6f, b/274800183).
Mudanças de comportamento
- As extensões
LiveData.map()
eLiveData.switchMap()
agora definem ovalue
doLiveData
retornado se oLiveData
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()
doViewModel
agora fecha imediatamente aCloseable
se oViewModel
já recebeu uma chamada paraonCleared()
(I4712e, b/280294730).
Correções de bugs
- No Lifecycle
2.6.2
: foi corrigido um problema em queSavedStateHandle
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 noSavedStateRegistry
pai e, em seguida, o estado era restaurado novamente Isso corrige a interação entre arememberSaveable
e oNavHost
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 viaLifecycle.currentStateFlow
, que retorna umStateFlow
em que ovalue
é oLifecycle.State
atual. (Ib212d, b/209684871). Lifecycle.Event
s agora podem ser observados como umFlow
comLifecycle.asFlow().
(If2c0f, b/176311030).- A API
LifecycleResumeEffect
foi adicionada para executarSideEffect
s do Compose com base em callbacks de eventosLifecycle.Event.ON_RESUME
eLifecycle.Event.ON_PAUSE
. (I60386, b/235529345). - A API
LifecycleStartEffect
foi adicionada para executarSideEffect
s do Compose com base em callbacks de eventosLifecycle.Event.ON_START
eLifecycle.Event.ON_STOP
. (I5a8d1, b/235529345). - A API
LifecycleEventEffect
foi adicionada para executarSideEffect
s do Compose com base emLifecycle.Event
. (Ic9794, b/235529345). - A extensão
Lifecycle.collectAsState()
foi adicionada para expor diretamente oLifecycle.State
comoState
do Compose. Isso é equivalente (e uma alternativa mais curta) alifecycle.currentStateFlow.collectAsState()
. (I11015, b/235529345).
Correções de bugs
- Agora, a extensão
LiveData.distinctUntilChanged()
define ovalue
doLiveData
retornado quando oLiveData
anterior tem um valor definido. Isso não muda o comportamento de observação. Os valores atualizados doLiveData
de origem ainda serão aplicados apenas quando você começar a observar oLiveData
retornado dedistinctUntilChanged()
(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 noSavedStateRegistry
pai e, em seguida, o estado era restaurado novamente Isso corrige a interação entre arememberSaveable
e oNavHost
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 SavedState1.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 propriedadeisInitialized
que indica se um valor explícito já foi definido noLiveData
. Isso permite distinguir entreliveData.value
que retornanull
porque nenhum valor foi definido ou um valornull
explícitoMediatorLiveData
agora inclui um construtor para definir um valor inicial- Foi adicionada uma nova extensão em
StateFlow
eFlow
decollectAsStateWithLifecycle()
que coleta de fluxos e representa o valor mais recente como estado do Compose, considerando o ciclo de vida. - Os métodos
Lifecycle.launchWhenX
eLifecycle.whenX
foram descontinuados, já que o uso de um agente de pausa pode gerar recursos desnecessários. É recomendável usarLifecycle.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 umObserver
criado em Kotlin agora corresponde à nulidade do tipo genérico Se você quiser queObserver.onChanged()
aceite um tipo anulável, instanciarObserver
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
eProcessLifecycleOwner
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 ovalue
doLiveData
retornado quando oLiveData
anterior tem um valor definido. Isso não muda o comportamento de observação. Os valores atualizados doLiveData
de origem ainda serão aplicados apenas quando você começar a observar oLiveData
retornado dedistinctUntilChanged()
(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 propriedadelifecycle
em vez de implementar a funçãogetLifecycle()
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 propriedadeviewModelStore
em vez de implementar a funçãogetViewModelStore()
anterior (I86409, b/240298691). - A extensão Kotlin em
LifecycleOwner
que fornece o campolifecycleScope
foi movida para o artefatolifecycle-common
delifecycle-runtime-ktx
(I41d78, b/240298691). - A extensão Kotlin em
Lifecycle
que fornece o campocoroutineScope
foi movida para o artefatolifecycle-common
delifecycle-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, comoTransformations.map
. O código Kotlin precisa usar a sintaxe do método de extensão Kotlin, que antes estava disponível apenas ao usar olifecycle-livedata-ktx
. Ao usar a linguagem de programação Java, as versões desses métodos que usam umandroidx.arch.core.util.Function
são descontinuadas e substituídas pelas versões que usam umaFunction1
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 naView
deandroidx.lifecycle.setViewTreeViewModelStoreOwner
eandroidx.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 propriedadesdefaultViewModelProviderFactory
edefaultViewModelCreationExtras
, em vez de implementar as funções correspondentes anteriores (Iaed9c, b/240298691). - Agora, o
Observer
é escrito em Kotlin. O métodoonChanged()
usa ovalue
de nome como parâmetro (Iffef2, I4995e, b/240298691). AndroidViewModel
,AbstractSavedStateViewModelFactory
,LifecycleService
,ServiceLifecycleDispatcher
eProcessLifecycleOwner
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 propriedadeisInitialized
que indica se um valor explícito já foi definido noLiveData
. Isso permite distinguir entreliveData.value
que retornanull
porque nenhum valor foi definido ou um valornull
explícito (Ibd018).
Mudanças na API
- As APIs
collectAsStateWithLifecycle()
delifecycle-runtime-compose
não estão mais no status experimental (I09d42, b/258835424). - Os métodos
Lifecycle.launchWhenX
eLifecycle.whenX
foram descontinuados, já que o uso de um agente de pausa pode gerar recursos desnecessários. É recomendável usarLifecycle.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 naView
deandroidx.lifecycle.setViewTreeLifecycleOwner
eandroidx.lifecycle.findViewTreeLifecycleOwner
para definir e encontrar um proprietário configurado anteriormente. Isso substitui a extensão Kotlin anterior emlifecycle-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 emlifecycle-reactivestreams-ktx
foram movidas para o módulolifecycle-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
eViewModelStore
estão escritos em Kotlin (Iadffd, I60034, I8c52c, I9593d, I01fe1, I59a23, b/240298691).
Correções de bugs
SavedStateHandle
não falha mais com umClassCastException
ao chamarget()
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 umcallbackFlow
em vez de usar a própria implementação doChannel
para garantir a segurança de linhas de execução e a preservação de contexto (I4a8b2, b/200596935).- A função
asLiveData
doFlowLiveData
agora preserva o valor inicial de umStateFlow
ao criar o novo objetoLiveData
(I3f530, b/157380488). - Do Lifecycle
2.5.1
: as implementações personalizadas deAndroidViewModelFactory
agora chamam corretamente a funçãocreate(modelClass)
ao usar o construtor com estado com oLifecycle
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
eFlow
decollectAsStateWithLifecycle
, 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 determinadoLifecycle.State
. Quando o ciclo de vida fica abaixo desseLifecycle.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çãocreate(modelClass)
ao usar o construtorAndroidViewModelFactory
com estado com oLifecycle
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 APIgetStateFlow()
que retorna umStateFlow
do Kotlin para monitorar mudanças de valor como umaalternativa ao uso deLiveData
.ViewModel CreationExtras: ao gravar um
ViewModelProvider.Factory
personalizado, não é mais necessário estenderAndroidViewModelFactory
ouAbstractSavedStateViewModelFactory
para ter acesso a umApplication
ouSavedStateHandle
, respectivamente. Em vez disso, esses campos são fornecidos a todas as subclassesViewModelProvider.Factory
comoCreationExtras
com a nova sobrecarga decreate
:create(Class<T>, CreationExtras)
. Esses extras são fornecidos automaticamente pela atividade ou pelo fragmento ao usar a Activity1.5.0
e o Fragment1.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 DSLviewModelFactory
do Kotlin que permite definir seuViewModelProvider.Factory
em termos de um ou mais inicializadores de lambda, um para cada classeViewModel
com suporte para a fábrica personalizada, usandoCreationExtras
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 APIviewModel()
que usa uma fábrica de lambdas para criar uma instância doViewModel
sem exigir a criação de umaViewModelProvider.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 emSavedStateHandle.saveable
que permitem um comportamento similar aorememberSaveable
apoiado peloSavedStateHandle
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 objetosCloseable
aoViewModel
que são fechados quando oViewModel
é apagado sem exigir trabalhos manuais emonCleared()
.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 implementeCloseable
: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 doviewModelScope
: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
deINITIALIZED
paraDESTROYED
agora sempre vai gerar umaIllegalStateException
, independentemente doLifecycle
ter um observador anexado. - O
LifecycleRegistry
agora vai limpar os observadores quando alcançarem o estadoDESTROYED
.
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 umaNullPointerException
quando recebe uma origemnull
em vez de propagar essa origemnull
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 noSavedStateHandle
(I8bb86, b/225014345).
Correções de bugs
- Foi corrigido um problema em que aninhar um
NavHost
em outroNavHost
em uma guia de navegação inferior não principal causava umaIllegalStateException
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 aoSavedStateHandle.saveable
para paridade comrememberSaveable
(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 porSavedStateHandleController
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 aSavedStateHandleSaver
, uma API experimental que garante que os valores em umSavedStateHandle
sejam integrados corretamente com o mesmo estado de instância salvo que orememberSaveable
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 deCreationExtras
mesmo quando inicializada com umSavedStateRegistryOwner
. 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 APIgetStateFlow()
que retorna umStateFlow
de Kotlin para monitorar mudanças de valor como uma alternativa ao uso deLiveData
(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 objetosCloseable
aoViewModel
que são fechados quando oViewModel
é apagado, sem exigir trabalhos manuais emonCleared()
(I55ea0). lifecycle-viewmodel
agora fornece umaInitializerViewModelFactory
que permite adicionar a lambda para processar classesViewModel
particulares, usandoCreationExtras
como a fonte de dados principal (If58fc, b/216687549).lifecycle-viewmodel-compose
agora oferece uma APIviewModel()
que usa uma fábrica de lambdas para criar uma instância doViewModel
sem exigir a criação de umaViewModelProvider.Factory
personalizada (I97fbb, b/216688927).
Mudanças na API
- Agora você pode criar um
ViewModel
comCreationExtras
usandolifecycle-viewmodel-compose
(I08887, b/216688927).
Mudanças de comportamento
- A tentativa de mover o
Lifecycle.State
doINITIALIZED
para oDESTROYED
agora sempre gerará umaIllegalStateException
, independentemente deLifecycle
ter um observador anexado (I7c390, b/177924329) LifecycleRegistry
agora vai limpar os observadores quando alcançarem o estadoDESTROYED
(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
eSavedStateViewModelFactory
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çãoLiveData
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 delifecycle-process
para depender de Startup 1.1.1, garantindo que as correções que impedem a classeProcessLifecycleInitializer
de gerar umaStartupException
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 umViewModel
(I340f7, b/177667711). - Agora, você pode criar um modelo de visualização com
CreationExtras
usando oAndroidViewModelFactory
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
: estaString
fornece acesso à chave personalizada que você transmitiu paraViewModelProvider.get()
.ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY
fornece acesso à classeApplication
.SavedStateHandleSupport.SAVED_STATE_REGISTRY_OWNER_KEY
fornece acesso aoSavedStateRegistryOwner
usado para construir esse ViewModel.SavedStateHandleSupport.VIEW_MODEL_STORE_OWNER_KEY
fornece acesso aoViewModelStoreOwner
usado para construir esse ViewModel.SavedStateHandleSupport.DEFAULT_ARGS_KEY
fornece acesso aoBundle
de argumentos que precisam ser usados para construir umSavedStateHandle
.
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 doSavedStateHandle
. 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 umaSavedStateHandle
reaparecia após a interrupção e recriação do processo, mesmo que especificamente removido daSavedStateHandle
. 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 classeProcessLifecycleInitializer
causava umaStartupException
(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 oLifecycleEventObserver
ou oDefaultLifecycleObserver
- A biblioteca
androidx.lifecycle:lifecycle-viewmodel-compose
foi adicionada. Ela fornece oviewModel()
que pode ser composto e oLocalViewModelStoreOwner
.- Alteração interruptiva de origem: o
ViewModelProvider
foi reescrito em Kotlin. O métodoViewModelProvider.Factory.create
não permite mais o uso de genéricos anuláveis.
- Alteração interruptiva de origem: o
- 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 delifecycle.lifecycle-common-java8
paralifecycle.lifecycle-common
. Olifecycle.lifecycle-common-java8
não oferece mais nenhuma funcionalidade extra em relação alifecycle.lifecycle-common
. Portanto, a dependência dele pode ser substituída porlifecycle.lifecycle-common
- A API que não é de corrotinas do
lifecycle-viewmodel-ktx
foi movida para o módulolifecycle-viewmodel
. O
lifecycle-process
agora usaandroidx.startup
para inicializar oProcessLifecycleOwner
.Anteriormente, isso era feito pelo
androidx.lifecycle.ProcessLifecycleOwnerInitializer
.Se você usava
tools:node="remove"
, a classeContentProvider
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 interfaceLifecycleEventObserver
ou aDefaultLifecycleObserver
(I5a8fa). - O DefaultLifecycleObserver foi movido de
androidx.lifecycle.lifecycle-common-java8
paraandroidx.lifecycle.lifecycle-common
. Oandroidx.lifecycle.lifecycle-common-java8
não oferece mais nenhuma funcionalidade extra em relação aandroidx.lifecycle.lifecycle-common
. Portanto, a dependência dele pode ser substituída porandroidx.lifecycle.lifecycle-common
(I021aa). - A API que não é de corrotinas do
lifecycle-viewmodel-ktx
foi movida para o módulolifecycle-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
paralifecycle-runtime-ktx
que detecta quandorepeateOnLifecycle
é usado incorretamente emonStart()
ouonResume()
foi adicionada (706078, b/187887400).
Mudanças na API
- A API
LifecycleOwner.addRepeatingJob
foi removida e substituída porLifecycle.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 outrosandroidx.startup.Initializer
s (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 usaandroidx.startup
para inicializar oProcessLifecycleOwner
.Anteriormente, isso era feito pelo
androidx.lifecycle.ProcessLifecycleOwnerInitializer
.Se você usava
tools:node="remove"
, a classeContentProvider
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 APILifecycle.repeatOnLifecycle
. Essa é uma alternativa à nova APILifecycleOwner.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 umViewModelStoreOwner
opcional, facilitando o trabalho com proprietários diferentes deLocalViewModelStoreOwner
. Por exemplo, agora você pode usarviewModel(navBackStackEntry)
para extrair um ViewModel associado a um gráfico de navegação específico (I2628d, b/188693123).
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
eandroidx.navigation:navigation-compose
sincronizem dependências emandroidx.compose.compiler:compiler:1.0.0-beta04
eandroidx.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 umViewModelStoreOwner
anulável para determinar melhor se umViewModelStoreOwner
está disponível na composição atual. As APIs que exigem umViewModelStoreOwner
, comoviewModel()
eNavHost
, ainda geram uma exceção se umViewModelStoreOwner
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çãoprovides
que pode ser usada comCompositionLocalProvider
, substituindo a APIasProvidableCompositionLocal()
(I45d24).
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 oLocalViewModelStoreOwner
foram movidos deandroidx.compose.ui.viewinterop
para este artefato no pacoteandroidx.lifecycle.viewmodel.compose
(I7a374).
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 chamarsetSavedStateProvider()
para determinada chave, fornecendo umSavedStateProvider
que receberá um callback parasaveState()
quando for solicitado que oSavedStateHandle
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 objetosLifecycleRegistry
que pertencem aos seus componentes, você pode desativar explicitamente as verificações usandoLifecycleRegistry.createUnsafe(...)
. Mas é necessário garantir que haja uma sincronização adequada quandoLifecycleRegistry
é acessado de diferentes linhas de execução.
- O LifecycleRegistry agora aplica 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)
aLifecycle.Event
para gerar oEvent
com umState
e uma direção de transição. O métodogetTargetState()
que fornece oState
para o qual o Lifecycle mudará diretamente após oEvent
foi adicionado. withStateAtLeast
: foram adicionadas APIsLifecycle.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étodoswhen*
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 APIsViewTreeLifecycleOwner.get(View)
eViewTreeViewModelStoreOwner.get(View)
permitem que você extraia, respectivamente, oLifecycleOwner
e oViewModelStoreOwner
contidos de uma instânciaView
. É necessário fazer upgrade para Activity1.2.0
, Fragment1.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 KotlinfindViewTreeLifecycleOwner
efindViewTreeViewModelStoreOwner
estão disponíveis emlifecycle-runtime-ktx
elifecycle-viewmodel-ktx
, respectivamente. - Descontinuação da extensão Kotlin
LiveData.observe()
: a extensão KotlinLiveData.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()
deSavedStateHandle
agora é consistente antes e depois de o estado ser salvo. Agora, ele inclui chaves usadas anteriormente comsetSavedStateProvider()
, além das chaves usadas comset()
egetLiveData()
(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 documentosasLiveData()
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)
aLifecycle.Event
para gerar oEvent
com umState
e uma direção de transição. O métodogetTargetState()
que fornece oState
para qual o Lifecycle mudará diretamente depois doEvent
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étodoswhen*
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 objetosLifecycleRegistry
que pertencem aos seus componentes, você pode desativar explicitamente as verificações com o uso deLifecycleRegistry.createUnsafe(...)
. Mas é necessário garantir que haja uma sincronização adequada quando esseLifecycleRegistry
é 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 comlifecycle-livedata-core-ktx
e especificamente comNullSafeMutableLiveData
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 paraonActive()
ouonInactive()
(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 valornull
era definido em umMutableLiveData
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ê chamesetSavedStateProvider()
para determinada chave, fornecendo umSavedStateProvider
que receberá um callback parasaveState()
quando for solicitado queSavedStateHandle
salve o estado dele (b/155106862).- Uma nova API
ViewTreeViewModelStoreOwner.get(View)
permite que você extraia a interfaceViewModelStoreOwner
contida com uma instânciaView
. É necessário fazer upgrade para Activity1.2.0-alpha05
, Fragment1.3.0-alpha05
e AppCompat1.3.0-alpha01
para preencher corretamente. Uma extensão KotlinfindViewModelStoreOwner()
foi adicionada alifecycle-viewmodel-ktx
(aosp/1295522).
Correções de bugs
- Um problema que fazia com que as verificações de Lint
MutableLiveData
lançadas no Lifecycle2.3.0-alpha01
fossem publicadas usando o artefatolifecycle-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 umApplication
nulo ao construtor para históricos de consulta melhores em que um deles não está disponível rapidamente, e o suporte paraAndroidViewModel
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 interfaceLifecycleOwner
contida com uma instânciaView
. É necessário fazer upgrade para Activity1.2.0-alpha01
e Fragment1.3.0-alpha01
para preencher corretamente. Uma extensãofindViewTreeLifecycleOwner
do Kotlin está disponível emlifecycle-runtime-ktx
(aosp/1182361, aosp/1182956). - Adição de uma nova verificação do Lint que avisa quando você define um valor
null
em umMutableLiveData
definido no Kotlin como não nulo. Isso está disponível ao usar os artefatoslivedata-core-ktx
oulivedata-ktx
(aosp/1154723, aosp/1159092). - Um novo artefato
lifecycle-runtime-testing
está disponível e fornece umTestLifecycleOwner
que implementaLifecycleOwner
e fornece umLifecycle
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).
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. Olifecycle-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 doViewModelProviders.of()
foi descontinuado. Você pode transmitir umFragment
ouFragmentActivity
ao novo construtorViewModelProvider(ViewModelStoreOwner)
para ter a mesma funcionalidade quando usar o Fragment1.2.0
. - Descontinuação do artefato
lifecycle-extensions
: com a descontinuação doViewModelProviders.of()
descrita acima, esta versão marca a descontinuação da última API emlifecycle-extensions
, e esse artefato agora será considerado completamente descontinuado. É altamente recomendável depender dos artefatos específicos necessários do Lifecycle (comolifecycle-service
, se você estiver usandoLifecycleService
, elifecycle-process
, se você estiver usandoProcessLifecycleOwner
) em vez delifecycle-extensions
, já que não haverá uma futura versão2.3.0
delifecycle-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 usarLifecycleEventObserver
.
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 emViewModelStore
e consultado com a fábrica padrão. - Correção de um uso de
Dispatchers.Main.immediate
emlaunchWhenCreated
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 deDispatchers.Main
em vez deDispatchers.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 interfaceLifecycleOwner
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 umaNullPointerException
ao usar a versão2.0.0
ou2.1.0
dolifecycle-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 deliveData
agora usamDispatchers.Main.immediate
em vez deDispatchers.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 implementarHasDefaultViewModelProviderFactory
para oferecer umViewModelProvider.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 umFragment
ouFragmentActivity
ao novo construtorViewModelProvider(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 porLiveDataScope.latestValue
, que rastreará o valor atual emitido do blocoliveData
.- Uma nova sobrecarga foi adicionada ao builder
liveData
, que recebe o parâmetrotimeout
como o tipoDuration
.
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 classeViewModel
, e as fábricas fornecidas por padrão por fragmentos e AppCompatActivity vão injetarSavedStateHandle
automaticamente. - Adição de AbstractSavedStateViewModelFactory. Ela permite que você crie fábricas personalizadas para
ViewModel
e forneça acesso aSavedStateHandle
.
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 umaIllegalStateException
(b/139093676). - Uma
IllegalStateException
ao usarAbstractSavedStateViewModelFactory
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 maisAbstractSavedStateViewModelFactory
, eSavedStateHandle
é 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 defragment
, e os construtoresSavedStateViewModelFactory(Fragment)
eSavedStateViewModelFactory(FragmentActivity)
relacionados foram removidos. Em vez disso,SavedStateViewModelFactory
agora é a fábrica padrão para Activity1.1.0-alpha02
, Fragment1.2.0-alpha02
e Navigation2.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 comoSavedStateViewModelFactory
.AbstractSavedStateVMFactory
foi renomeado comoAbstractSavedStateViewModelFactory
.
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 objetoSavedStateHandle
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 classeGenericLifecycleObserver
oculta. - Adicionadas extensões ktx para os métodos
LiveData.observe
eTransformations.*
. Transformations.distinctUntilChanged
, que cria um novo objeto LiveData que não emite um valor até que o valorLiveData
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 doViewModel
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.
Mudanças na API
- Alteração interruptiva: a API relacionada a
by viewModels()
e aby activityViewModels()
mudou para oferecer suporte direto aViewModelStore
, e não apenas a umViewModelStoreOwner
(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 deViewModelProvider.Factory
, não combinou bem com novos recursos, como delegação de propriedades em Kotlinby 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étodosetCurrentState()
que substitui o método descontinuadosetState()
(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 classeViewModelStore
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 classeGenericLifecycleObserver
oculta. - Adicionadas extensões ktx para os métodos
LiveData.observe
eTransformations.*
. - O método
Transformations.distinctUntilChanged
foi adicionado. Ele cria um novo objetoLiveData
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 recebekey
eClass
no métodocreate
.
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
Mudanças na API
- Os
LifecycleActivity
eLifecycleFragment
obsoletos foram descontinuados. UseFragmentActivity
,AppCompatActivity
ou ofereça suporte aFragment
. - Adicionadas anotações
@NonNull
aViewModelProviders
eViewModelStores
- O construtor
ViewModelProviders
foi descontinuado. Use os métodos estáticos dele diretamente. - O uso de
ViewModelProviders.DefaultFactory
foi descontinuado. UseViewModelProvider.AndroidViewModelFactory
. - Adicionado o método
ViewModelProvider.AndroidViewModelFactory.getInstance(Application)
estático para recuperar umaFactory
estática adequada para criar instânciasViewModel
eAndroidViewModel
.