Android Academy · Lección

ViewModel y LiveData

Sobreviva a los cambios de configuración con ViewModel. Exponga flujos de datos reactivos con LiveData y obsérvelos en Activities y Fragments.

ViewModel y LiveData es una lección gratuita de Android Academy en CoddyKit. Esta es la lección 1 de 6. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Android Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Android Academy incluye 6 lecciones en total.

El problema de las Activities

Almacenar datos directamente en una Activity presenta dos problemas importantes:

Cuando el usuario gira el teléfono, la Activity se destruye y se vuelve a crear; se pierden todos los datos
Si obtiene datos de la red en onCreate, la solicitud se repite en cada giro; es un desperdicio

ViewModel resuelve ambos problemas.

¿Qué es ViewModel?

ViewModel es un componente de la arquitectura de Android que:

Sobrevive a los cambios de configuración (giro de pantalla, cambio de tema)
Contiene datos relacionados con la interfaz y lógica de negocio
Solo se destruye cuando el usuario abandona la pantalla de forma permanente

Regla práctica: si los datos deben sobrevivir al giro de pantalla, colóquelos en un ViewModel.

Crear un ViewModel

Extienda ViewModel y añádalo a las dependencias de 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
    }
}

Obtener un ViewModel en una Activity

Use ViewModelProvider (o el delegado by viewModels()) para obtener una instancia 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()
        }
    }
}

¿Qué es LiveData?

LiveData es un contenedor de datos observable. La interfaz observa los valores de LiveData y se actualiza automáticamente cuando cambia el valor.

Consciente del ciclo de vida: solo actualiza los observadores activos (no se producen fallos cuando la Activity está en segundo plano)
Siempre actualizado: los observadores nuevos reciben inmediatamente el valor más reciente

LiveData en ViewModel

Use MutableLiveData de forma privada (ViewModel puede escribir) y expóngalo públicamente como LiveData (la interfaz solo puede observarlo):

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

Observar LiveData en una Activity

Llame a .observe(lifecycleOwner) { value -> } para reaccionar a los cambios:

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 frente a State Flow

LiveData es el enfoque clásico. En el código Kotlin moderno se suele usar StateFlow de Kotlin Coroutines:

StateFlow — basado en corrutinas, sin dependencia de Android
Se recopila mediante repeatOnLifecycle en la Activity
Es mejor para gestionar estados complejos

Ambos funcionan bien: LiveData es más sencillo para empezar; verá StateFlow en aplicaciones más grandes.

ViewModel con varios observadores

Varios componentes de la interfaz pueden observar el mismo LiveData. Por ejemplo, tanto un TextView como el estado enabled de un Button pueden reaccionar al mismo valor de datos en el ViewModel, sin necesidad de añadir código adicional al ViewModel.

Esto separa las responsabilidades de forma clara: ViewModel mantiene el estado y la interfaz solo observa y representa.

Comprobación rápida

¿Cuándo se destruye un ViewModel?

Repaso: ViewModel y LiveData

Ahora sabe cómo crear interfaces conscientes del ciclo de vida:

ViewModel sobrevive a los cambios de configuración (como el giro de pantalla)
Use by viewModels() para obtener un ViewModel en una Activity
Patrón MutableLiveData (privado) / LiveData (público)
Observe con .observe(this) { value -> updateUI(value) }
La interfaz se actualiza automáticamente; no es necesario actualizarla manualmente

A continuación: conserve los datos permanentemente con la base de datos Room.

Preguntas frecuentes

¿La lección «ViewModel y LiveData» es gratis?

Sí — el texto completo de «ViewModel y LiveData» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Android Academy, actualiza a CoddyKit PRO. El curso de Android Academy incluye 6 lecciones en total.

¿Qué aprenderé en «ViewModel y LiveData»?

Sobreviva a los cambios de configuración con ViewModel. Exponga flujos de datos reactivos con LiveData y obsérvelos en Activities y Fragments. Practicas Android Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Android Academy?

No se requiere experiencia previa. Android Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 6.

¿Cuánto tiempo toma la lección «ViewModel y LiveData»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Android Academy?

Sí. Cada lección de Android Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Android Academy