Android Academy · Lezione

ViewModel e LiveData

Gestisca le modifiche di configurazione con ViewModel. Esponga flussi di dati reattivi con LiveData e li osservi nelle Activities e nei Fragments.

ViewModel e LiveData è una lezione Android Academy gratuita su CoddyKit. Questa è la lezione 1 di 6. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Android Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Android Academy include 6 lezioni in totale.

Il problema delle Activity

Salvare i dati direttamente in un'Activity comporta due problemi principali:

Quando l'utente ruota il telefono, l'Activity viene distrutta e ricreata: tutti i dati vengono persi
Se recupera i dati dalla rete in onCreate, questi vengono recuperati di nuovo a ogni rotazione: è uno spreco di risorse

ViewModel risolve entrambi i problemi.

Che cos'è ViewModel?

ViewModel è un componente dell'architettura Android che:

Sopravvive alle modifiche di configurazione (rotazione, cambio del tema)
Contiene i dati relativi all'interfaccia utente e la logica di business
Viene distrutto solo quando l'utente abbandona definitivamente la schermata

Regola generale: se un dato deve sopravvivere alla rotazione, lo inserisca in un ViewModel.

Creazione di un ViewModel

Estenda ViewModel e aggiunga la relativa dipendenza alle dipendenze 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
    }
}

Recupero di un ViewModel in un'Activity

Usi ViewModelProvider (oppure il delegate by viewModels()) per ottenere un'istanza di 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()
        }
    }
}

Che cos'è LiveData?

LiveData è un contenitore osservabile di dati. L'interfaccia utente osserva i valori di LiveData e si aggiorna automaticamente quando il valore cambia.

Consapevole del ciclo di vita: aggiorna solo gli observer attivi (nessun arresto anomalo quando l'Activity è in background)
Sempre aggiornato: i nuovi observer ricevono immediatamente il valore più recente

LiveData nel ViewModel

Usi MutableLiveData privatamente (il ViewModel può scrivervi) ed esponga pubblicamente LiveData (l'interfaccia utente può solo osservarlo):

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

Osservazione di LiveData nell'Activity

Chiami .observe(lifecycleOwner) { value -> } per reagire alle modifiche:

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 e State Flow

LiveData è l'approccio classico. Il codice Kotlin moderno usa spesso StateFlow di Kotlin Coroutines:

StateFlow — basato sulle coroutine, senza dipendenze da Android
Raccolto con repeatOnLifecycle nell'Activity
Più adatto alla gestione di stati complessi

Entrambi funzionano bene: LiveData è più semplice per iniziare, mentre StateFlow viene usato nelle app più grandi.

ViewModel con più observer

Più componenti dell'interfaccia utente possono osservare lo stesso LiveData. Ad esempio, sia un TextView sia lo stato enabled di un Button possono reagire allo stesso valore di dati nel ViewModel, senza alcun codice aggiuntivo nel ViewModel.

In questo modo le responsabilità sono separate in modo chiaro: il ViewModel contiene lo stato, mentre l'interfaccia utente si limita a osservarlo e visualizzarlo.

Verifica rapida

Quando viene distrutto un ViewModel?

Riepilogo: ViewModel e LiveData

Ora sa come creare interfacce utente consapevoli del ciclo di vita:

ViewModel sopravvive alle modifiche di configurazione (rotazione)
Usi by viewModels() per ottenere un ViewModel in un'Activity
Pattern MutableLiveData (privato) / LiveData (pubblico)
Osservi con .observe(this) { value -> updateUI(value) }
L'interfaccia utente si aggiorna automaticamente: non è necessario alcun aggiornamento manuale

Prossimo argomento: rendere i dati permanenti con il database Room.

Domande Frequenti

La lezione «ViewModel e LiveData» è gratuita?

Sì — il testo completo di «ViewModel e LiveData» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Android Academy, passa a CoddyKit PRO. Il corso Android Academy include 6 lezioni in totale.

Cosa imparerò in «ViewModel e LiveData»?

Gestisca le modifiche di configurazione con ViewModel. Esponga flussi di dati reattivi con LiveData e li osservi nelle Activities e nei Fragments. Eserciti Android Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Android Academy?

Non è richiesta alcuna esperienza precedente. Android Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 6.

Quanto tempo richiede la lezione «ViewModel e LiveData»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Android Academy?

Sì. Ogni lezione Android Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Android Academy