Android Academy · Leçon

Le cycle de vie Android

Comprenez les cycles de vie de l'activité et de la composition.

Le cycle de vie Android est une leçon Android Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. 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 4 leçons au total.

Qu’est-ce que le cycle de vie ?

Chaque activité Android traverse une série d’états lorsque l’utilisateur ouvre votre application, la quitte, puis y revient. C’est le cycle de vie.

Le comprendre vous permet de démarrer et d’arrêter les opérations au bon moment.

Rappels principaux d’une activité

Les rappels classiques du cycle de vie d’une activité s’exécutent dans cet ordre :

onCreate — l’activité est en cours de création.
onStart — elle devient visible.
onResume — elle est au premier plan et interactive.
onPause / onStop / onDestroy — elle est quittée.

Un flux typique

Ouverture d’une application : onCreate → onStart → onResume.

Appui sur le bouton d’accueil : onPause → onStop.

Retour dans l’application : onRestart → onStart → onResume.

États et événements du cycle de vie

La bibliothèque Lifecycle de Jetpack modélise cela avec des états (CREATED, STARTED, RESUMED, DESTROYED) et des événements (ON_CREATE, ON_START, ...).

Les composants peuvent observer ces éléments au lieu de remplacer les rappels bruts.

LifecycleOwner

Les activités, les fragments et les hôtes Compose sont des LifecycleOwners. Ils exposent un objet Lifecycle que d’autres composants peuvent observer.

val owner: LifecycleOwner = this // an Activity
val lifecycle = owner.lifecycle

Pourquoi cela compte pour les ressources

De nombreuses ressources ne doivent être actives que lorsque l’écran est visible :

Mises à jour de la position.
Écouteurs de capteurs.
Sessions de caméra.

Démarrez-les dans onStart/onResume et arrêtez-les dans onStop/onPause pour économiser la batterie et éviter les fuites.

Le cycle de vie dans Jetpack Compose

Les composables ne disposent pas des rappels d’une activité. Ils ont à la place un cycle de vie de la composition : ils entrent dans la composition, sont recomposés, puis la quittent finalement.

Réagir à la composition avec DisposableEffect

DisposableEffect exécute la configuration lorsqu’un composable entre dans la composition, puis le nettoyage lorsqu’il la quitte.

@Composable
fun Screen() {
    DisposableEffect(Unit) {
        // setup, e.g. register listener
        onDispose {
            // cleanup when leaving composition
        }
    }
}

Observer le cycle de vie réel dans Compose

Pour réagir aux événements réels du cycle de vie d’une activité depuis un composable, observez le LifecycleOwner avec un DefaultLifecycleObserver.

@Composable
fun OnResume(onResume: () -> Unit) {
    val owner = LocalLifecycleOwner.current
    DisposableEffect(owner) {
        val obs = object : DefaultLifecycleObserver {
            override fun onResume(o: LifecycleOwner) = onResume()
        }
        owner.lifecycle.addObserver(obs)
        onDispose { owner.lifecycle.removeObserver(obs) }
    }
}

Le ViewModel et le cycle de vie

Souvenez-vous-en : le ViewModel survit aux états individuels du cycle de vie tels que onStart/onStop. Il n’est supprimé que lorsque le propriétaire a définitivement disparu. C’est précisément pourquoi vous pouvez y conserver l’état en toute sécurité.

Assembler le tout

Un écran bien structuré :

Conserve l’état durable dans un ViewModel.
Démarre et arrête les ressources nécessaires uniquement lorsque l’écran est visible, en tenant compte du cycle de vie.
Ne collecte les flux que lorsque l’interface utilisateur est au moins à l’état STARTED (leçon suivante).

Vérification rapide

Vérifiez vos connaissances du cycle de vie.

Récapitulatif

Vous avez appris que :

Les activités traversent les états CREATED, STARTED, RESUMED et DESTROYED.
Compose possède son propre cycle de vie de composition, géré avec DisposableEffect.
Il faut observer LifecycleOwner pour réagir aux événements réels du cycle de vie.
Les ViewModels survivent délibérément à ces états.

Questions Fréquemment Posées

La leçon « Le cycle de vie Android » est-elle gratuite ?

Oui — le texte complet de « Le cycle de vie Android » 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 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Le cycle de vie Android » ?

Comprenez les cycles de vie de l'activité et de la composition. 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 3 sur 4.

Combien de temps prend la leçon « Le cycle de vie Android » ?

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