LiveData: O que é, para o que serve e como utilizar?

Afinal, o que é o LiveData?

Segundo a documentação do próprio Android:

LiveData is an observable data holder class. Unlike a regular observable, LiveData is lifecycle-aware, meaning it respects the lifecycle of other app components, such as activities, fragments, or services. This awareness ensures LiveData only updates app component observers that are in an active lifecycle state.

Em outras palavras, basicamente o LiveData é um “tipo” de atributo observável. Isso significa que qualquer um que esteja observando este atributo será notificado sempre que o seu conteúdo for modificado (caso o observador esteja ativo!).

E qual o seu grande diferencial? É exatamente o fato de que ele só irá enviar atualizações de seu estado para observadores que estejam ativos: isso vai impedir que sejam notificados observadores de fragments ou activities que estejam destruídos ou em pausa, evitando qualquer tipo de crash ou exception.

E para o que serve?

Usando o LiveData, você será capaz de criar uma comunicação reativa entre o seu ViewModel e o seu fragment ou sua activity. Não quer dizer que você só poderá utilizar a funcionalidade para esta finalidade.

Isso significa basicamente que toda vez que o seu atributo (que possivelmente está no ViewModel) que está sendo observado ter o seu conteúdo atualizado, o seu observador (que possivelmente está no seu fragment ou activity) será avisado, receberá o conteúdo atualizado e fará uma série de ações em cima desse acontecimento e possivelmente usando esse conteúdo.

Como utilizar?

Demonstrarei o uso do LiveData criando uma Activity, um Fragment e um ViewModel para o cadastro de uma conta (de um aplicativo de controle financeiro).

Primeiro, nossa Activity:

O xml da nossa Activity é bem básico, contém apenas um container para inserirmos nosso fragment:

Segundo, nosso ViewModel:

Note que existem duas variáveis do tipo MutableLiveData<>. Contudo, iremos dar foco na variável mShouldShowProgressDialog (linha 11) e também o método para fazer o get deste atributo: getShouldShowProgressDialogLiveData (linha 26).

A variável será utilizada para indicar se o dialog de progresso (aquela bolinha carregando durante operações assíncronas em geral) deve ser exibida.

O tipo de dado MutableLiveData é utilizado para indicar que o atributo é do tipo LiveData, porém mutável. Também existe o tipo de dado LiveData, ambos do pacote androidx.lifecycle, mas este, por sua vez, não é mutável: repare que nem é possível usar um método setValue ou postValue.

Tanto o MutableLiveData quanto o LiveData podem ser holders para qualquer tipo de atributo: neste caso utilizamos um Boolean, mas poderia ser String, Long, Integer, ContaCadastro ou qualquer classe que você quiser criar.

Por último e tão importante para este artigo quanto nosso ViewModel, o Fragment:

Nosso observable, mShouldShowProgressDialogObserver (linha 6), é setupado dentro do método setupObservers() e o método que realiza a implementação do “onChanged”, chamado ao ser modificado o valor do nosso MutableLiveData, é o createShouldShowProgressDialogObserver (linha 76).

Nossa variável mShouldShowProgressDialogObserver é do tipo Observer<Boolean>, pois é ela quem irá observar nosso LiveData no ViewModel. Repare que ela também tem um Type (<Boolean>) e ele deve ser igual ao type do nosso MutableLiveData, no ViewModel:

Ao instanciar nossa classe CadastroContaFragment, realizamos a criação do nosso observer que é basicamente a implementação do método onChanged:

No caso em questão nós o implementamos utilizando lambda, mas você também poderia implementá-lo no formato convencional (classe anônima). Neste caso, ficaria algo assim:

Neste trecho de código, repare que o método que sobrescrevemos se chama onChanged: literalmente fazemos algo quando uma mudança ocorre.

Nesse caso nós iremos exibir o dialog de progress se a variável recebida for true e esconder se for false. Verifique no código da classe ContaCadastroFragment o corpo do método showProgressDialog() e hideProgressDialog(), se houver interesse em ver como exibimos ou escondemos o progress dialog.

Até este ponto já temos nossa variável a ser observada, nossa variável observadora e também o comportamento a ser executado ao receber a notificação de atualização de valor. Falta apenas vincularmos nosso observador ao observado. Nós faremos isso neste trecho de código:

O trecho em negrito busca a variável do tipo MutableLiveData do nosso ViewModel e chama o método observe, que é o cara que irá vincular o nosso observável (a MutableLiveData) com o observador, que contém o método onChanged. Como parâmetro, passamos o LifecycleOwner e o observador (o observer que declaramos lá nas variáveis membros de classe — mShouldShowProgressDialogObserver).

Pronto! Ao fazer um mShouldShowProgressDialog.setValue(boolean), teremos nosso observer no Fragment notificado e nosso dialog de progresso será exibido ou escondido, dependendo do valor inserido no LiveData.

Para deixar a estrutura completinha, deixarei também o xml do nosso Fragment aqui:

Para testar

Você pode obter este código neste repositório, no meu github. Clone em sua máquina, rode o projeto em um emulador ou no seu celular e faça o teste.

Importante: na chamada em RxJava utilizei o método “delay” para evidenciar o loading, pois o insert no banco acaba sendo muito rápido. Sendo assim, num cenário real, o delay não precisaria (e nem deveria!) existir.

Concluindo…

Você já havia ouvido falar em Observables ou tinha utilizado algum deles? Tem alguma sugestão ou outra forma de utilizar? Conta pra gente! É bem provável que conseguiremos evoluir com sua sugestão!