Android Academy · Aula

ViewModel e LiveData

Sobreviva a mudanças de configuração com ViewModel. Exponha fluxos de dados reativos com LiveData e observe-os em Activities e Fragments.

ViewModel e LiveData é uma aula grátis de Android Academy no CoddyKit. Esta é a aula 1 de 6. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Android Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Android Academy inclui 6 aulas no total.

O problema das Activities

Armazenar dados diretamente em uma Activity causa dois problemas importantes:

Quando o usuário gira o telefone, a Activity é destruída e recriada — todos os seus dados são perdidos
Se você buscar dados da rede em onCreate, eles serão buscados novamente a cada rotação — um desperdício

ViewModel resolve os dois problemas.

O que é ViewModel?

ViewModel é um componente da arquitetura do Android que:

Sobrevive a alterações de configuração (rotação, mudança de tema)
Armazena dados relacionados à interface e lógica de negócio
É destruído somente quando o usuário sai permanentemente da tela

Regra prática: se os dados devem sobreviver à rotação, coloque-os em um ViewModel.

Criando um ViewModel

Estenda ViewModel e adicione-o às suas dependências do Gradle:

// app/build.gradle:
// implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.7.0'
// implementation 'androidx.lifecycle:lifecycle-livedata-ktx:2.7.0'

import androidx.lifecycle.ViewModel

class CounterViewModel : ViewModel() {

    var count = 0
        private set

    fun increment() {
        count++
    }

    fun reset() {
        count = 0
    }
}

Obtendo um ViewModel na Activity

Use ViewModelProvider (ou o delegado by viewModels()) para obter uma instância de ViewModel:

import androidx.activity.viewModels

class CounterActivity : AppCompatActivity() {

    private lateinit var binding: ActivityCounterBinding
    // Android manages the ViewModel lifecycle — never instantiate it yourself
    private val viewModel: CounterViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityCounterBinding.inflate(layoutInflater)
        setContentView(binding.root)

        // This shows the count is preserved after rotation!
        binding.tvCount.text = viewModel.count.toString()

        binding.btnPlus.setOnClickListener {
            viewModel.increment()
            binding.tvCount.text = viewModel.count.toString()
        }
    }
}

O que é LiveData?

LiveData é um contêiner de dados observável. A interface observa os valores de LiveData e é atualizada automaticamente quando o valor muda.

Consciente do ciclo de vida — atualiza somente observadores ativos (sem falhas quando a Activity está em segundo plano)
Sempre atualizado — novos observadores recebem imediatamente o valor mais recente

LiveData no ViewModel

Use MutableLiveData privadamente (o ViewModel pode gravar) e exponha-o publicamente como LiveData (a interface só pode observar):

import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel

class CounterViewModel : ViewModel() {

    private val _count = MutableLiveData(0)
    val count: LiveData<Int> = _count  // read-only for the UI

    fun increment() {
        _count.value = (_count.value ?: 0) + 1
    }

    fun reset() {
        _count.value = 0
    }
}

Observando LiveData na Activity

Chame .observe(lifecycleOwner) { value -> } para reagir às alterações:

class CounterActivity : AppCompatActivity() {

    private val viewModel: CounterViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // ...

        // Automatically updates TextView whenever count changes
        viewModel.count.observe(this) { count ->
            binding.tvCount.text = count.toString()
        }

        binding.btnPlus.setOnClickListener { viewModel.increment() }
        binding.btnReset.setOnClickListener { viewModel.reset() }
    }
}

LiveData versus State Flow

LiveData é a abordagem clássica. O código Kotlin moderno costuma usar StateFlow das Corrotinas do Kotlin:

StateFlow — baseado em corrotinas, sem dependência do Android
Coletado com repeatOnLifecycle na Activity
Melhor para o gerenciamento de estados complexos

Ambos funcionam bem — LiveData é mais simples para começar; você verá StateFlow em aplicativos maiores.

ViewModel com vários observadores

Vários componentes da interface podem observar o mesmo LiveData. Por exemplo, tanto um TextView quanto o estado de habilitação de um Button podem reagir ao mesmo valor de dados no ViewModel — sem nenhum código extra no ViewModel.

Isso separa as responsabilidades de forma clara: o ViewModel mantém o estado, e a interface apenas observa e renderiza.

Verificação rápida

Quando um ViewModel é destruído?

Recapitulação: ViewModel e LiveData

Agora você sabe como criar interfaces cientes do ciclo de vida:

ViewModel sobrevive a alterações de configuração (rotação)
Use by viewModels() para obter um ViewModel em uma Activity
Padrão MutableLiveData (privado) / LiveData (público)
Observe com .observe(this) { value -> updateUI(value) }
A interface é atualizada automaticamente — não é necessário atualizar manualmente

A seguir: persista dados permanentemente com o banco de dados Room.

Perguntas Frequentes

A aula “ViewModel e LiveData” é grátis?

Sim — o texto completo de “ViewModel e LiveData” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Android Academy, atualize para CoddyKit PRO. O curso de Android Academy inclui 6 aulas no total.

O que vou aprender em “ViewModel e LiveData”?

Sobreviva a mudanças de configuração com ViewModel. Exponha fluxos de dados reativos com LiveData e observe-os em Activities e Fragments. Você pratica Android Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Android Academy?

Nenhuma experiência prévia é necessária. Android Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 6.

Quanto tempo leva a aula “ViewModel e LiveData”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Android Academy?

Sim. Cada aula de Android Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Android Academy