Android Academy · Leçon

ViewModel et LiveData

Résistez aux changements de configuration avec ViewModel. Exposez des flux de données réactifs avec LiveData et observez-les dans les Activities et les Fragments.

Leçon 1 sur 611 étapes

ViewModel et LiveData est une leçon Android Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 6. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Android Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Android Academy comprend 6 leçons au total.

Le problème des Activities

Stocker directement les données dans une Activity pose deux problèmes majeurs :

Lorsque l'utilisateur fait pivoter le téléphone, l'Activity est détruite puis recréée — toutes vos données sont perdues
Si vous récupérez des données sur le réseau dans onCreate, elles sont récupérées à nouveau à chaque rotation — ce qui est inutile

ViewModel résout ces deux problèmes.

Qu'est-ce qu'un ViewModel ?

ViewModel est un composant de l'architecture Android qui :

Survit aux changements de configuration (rotation, changement de thème)
Conserve les données liées à l'interface et la logique métier
N'est détruit que lorsque l'utilisateur quitte définitivement l'écran

Règle générale : si les données doivent survivre à une rotation, placez-les dans un ViewModel.

Création d'un ViewModel

Étendez ViewModel et ajoutez-le à vos dépendances 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
    }
}

Obtenir un ViewModel dans une Activity

Utilisez ViewModelProvider (ou le délégué by viewModels()) pour obtenir une instance 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'est-ce que LiveData ?

LiveData est un conteneur de données observable. L'interface utilisateur observe les valeurs de LiveData et se met automatiquement à jour lorsque la valeur change.

Conscient du cycle de vie — met à jour uniquement les observateurs actifs (aucun plantage lorsque l'Activity est en arrière-plan)
Toujours à jour — les nouveaux observateurs reçoivent immédiatement la dernière valeur

LiveData dans un ViewModel

Utilisez MutableLiveData en privé (le ViewModel peut écrire) et exposez-le publiquement sous forme de LiveData (l'interface peut uniquement l'observer) :

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

Observation de LiveData dans une Activity

Appelez .observe(lifecycleOwner) { value -> } pour réagir aux changements :

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

LiveData est l'approche classique. Le code Kotlin moderne utilise souvent StateFlow des coroutines Kotlin à la place :

StateFlow — basé sur les coroutines, sans dépendance à Android
Collecté avec repeatOnLifecycle dans l'Activity
Mieux adapté à la gestion d'états complexes

Les deux solutions fonctionnent bien : LiveData est plus simple pour débuter, tandis que vous verrez StateFlow dans les applications plus importantes.

ViewModel avec plusieurs observateurs

Plusieurs composants de l'interface peuvent observer le même LiveData. Par exemple, un TextView et l'état activé d'un Button peuvent tous deux réagir à la même valeur de données dans le ViewModel, sans code supplémentaire dans le ViewModel.

Cela sépare clairement les responsabilités : le ViewModel conserve l'état, tandis que l'interface se contente de l'observer et de l'afficher.

Vérification rapide

Quand un ViewModel est-il détruit ?

Réponds-y dans la leçon interactive

Récapitulatif : ViewModel et LiveData

Vous savez maintenant créer des interfaces respectueuses du cycle de vie :

ViewModel survit aux changements de configuration (rotation)
Utilisez by viewModels() pour obtenir un ViewModel dans une Activity
Modèle MutableLiveData (privé) / LiveData (public)
Observez avec .observe(this) { value -> updateUI(value) }
L'interface se met automatiquement à jour — aucune actualisation manuelle n'est nécessaire

Ensuite : conservez définitivement les données avec la base de données Room.

Gratuit pour commencer

Apprends Kotlin avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 36
Leçons: 152

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « ViewModel et LiveData » est-elle gratuite ?

Oui — le texte complet de « ViewModel et LiveData » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Android Academy, passe à CoddyKit PRO. Le cours Android Academy comprend 6 leçons au total.

Qu'est-ce que j'apprendrai dans « ViewModel et LiveData » ?

Résistez aux changements de configuration avec ViewModel. Exposez des flux de données réactifs avec LiveData et observez-les dans les Activities et les Fragments. Tu pratiques Android Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Android Academy ?

Aucune expérience préalable n'est requise. Android Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 6.

Combien de temps prend la leçon « ViewModel et LiveData » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Android Academy ?

Oui. Chaque leçon Android Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Android Academy