Cycle de vie des activités Android : guide avancé avec exemples et conseils

El Cycle de vie des activités dans Android C'est le pilier essentiel de la conception, de la programmation et de l'optimisation des applications mobiles sur cette plateforme. Chaque écran d'une application Android est une instance de Activité, et la façon dont l'utilisateur navigue, change d'application, fait pivoter l'appareil ou reçoit des appels a un impact direct sur les états internes de cette activité. Comprendre ce cycle est essentiel pour tout développeur souhaitant créer des applications robustes, rapides et hautement réactives. expérience utilisateur impeccable.

Qu’est-ce qu’une activité sur Android et pourquoi est-elle si importante ?

Une Activité Il s'agit de bien plus qu'un simple affichage graphique : il représente l'unité fondamentale d'interaction entre l'utilisateur et l'application. D'un point de vue technique, une activité est une classe Java/Kotlin qui étend Activity o AppCompatActivity et est déclaré dans le fichier AndroidManifest.xmlChaque fois que l'utilisateur ouvre un écran, effectue une action importante ou navigue entre des fonctionnalités, une activité gère les ressources, la logique et l'interface.

Le système Android gère les activités à l'aide d'une pile, permettant à l'utilisateur de revenir aux écrans précédents grâce au bouton « Retour ». Android gère également automatiquement le cycle de vie, libérant des ressources lorsqu'une activité n'est plus pertinente, afin d'optimiser la mémoire et l'autonomie de la batterie.

Cela implique que Il n'y a pas de fonction main() comme dans d'autres langages: Android décide quelle activité démarre en premier, quand l'arrêter, la recréer ou la terminer, en fonction de l'interaction de l'utilisateur et de l'état de l'appareil.

Pourquoi est-il essentiel de maîtriser le cycle de vie de l’activité ?

Comprendre et gérer le cycle de vie est essentiel à la qualité de toute application Android :

Empêche les fuites de mémoire:Si vous ne libérez pas de ressources au bon moment, vous risquez de manquer de mémoire système et de provoquer des arrêts inattendus.
Empêche la perte d'informations utilisateur:Si vous n'enregistrez pas l'état de l'écran lors de sa modification, par exemple en le faisant pivoter, les informations peuvent disparaître, ce qui frustre l'utilisateur.
Offre une expérience fluide même en cas d'interruptions:Lors de la réception d'un appel, du changement d'application ou de la rotation de l'appareil, l'application doit réagir de manière élégante et rapide.
Permet d'optimiser les ressources (CPU, batterie, capteurs):Actif uniquement lorsque cela est strictement nécessaire.
Facilite la navigation entre les écrans (Intents, backstack):Les actions et les résultats doivent être gérés en fonction du cycle de vie de chaque Activité.

Principaux états et rappels du cycle de vie d'une activité

Le cycle de vie d'une activité est géré par des méthodes de rappel automatiquement invoquées par Android. Chacune marque un point précis de la vie de l'écran :

onCreate(Bundle savedInstanceState)Initialisation et création de l'interface. Ici, la mise en page est agrandie et les ressources de base sont configurées.
onStart ():L'activité devient visible mais n'est pas encore interactive.
pour résumer():L'activité occupe une place centrale et est entièrement interactive.
onPause (): L'activité perd le focus mais peut toujours être partiellement visible (par exemple, une boîte de dialogue qui se chevauche).
onStop (): L'activité n'est plus visible, elle reste en mémoire mais ne consomme pas de ressources actives.
onRestart (): Invoqué si l'activité a été arrêtée et revient au premier plan.
onDestroy ():L'activité est sur le point d'être détruite et doit libérer toutes les ressources.

Explication détaillée de chaque méthode et des meilleures pratiques

onCreate (Bundle)

El première méthode à exécuter dans la vie d'une activité. L'initialisation complète est effectuée ici :

L'interface utilisateur est gonflée par setContentView(R.layout.tu_layout)
Les données sont récupérées à partir du Intent qui a lancé l'activité
Les variables, les ViewModels, les adaptateurs et les écouteurs sont initialisés
Les données enregistrées sont restaurées savedInstanceState le cas échéant

Il ne s'exécute qu'une fois par instance. Toute initialisation lourde doit se dérouler ici, mais elle ne doit pas bloquer le thread principal.

onStart ()

Marque le moment où l'activité devient visibleL'utilisateur peut le voir, mais pas nécessairement interagir avec lui (il n'a pas encore le focus). Idéal pour les mises à jour non critiques de l'interface utilisateur ou le lancement de ressources visuelles.

pour résumer()

L'activité prend le dessus ; l'utilisateur peut appuyer, faire défiler, taper, etc. Il est maintenant temps de :

Réactiver les capteurs
Reprendre les animations ou les processus mis en pause
Mettre à jour l'interface utilisateur en fonction des modifications externes

Tout ce qui nécessite que l’activité soit visible et active doit être démarré ici et arrêté ici. onPause ().

onPause ()

Android l'invoque si l'activité est sur le point de perdre le focus : lorsqu'une boîte de dialogue apparaît, une autre activité est démarrée par-dessus ou l'utilisateur s'éloigne.

Mettre en pause les animations, la musique, les capteurs et les tâches en arrière-plan
Stocke des données éphémères ou continues, mais pas des données persistantes
Maintient la méthode très léger; ce n'est pas le moment de sauvegarder des informations critiques ou d'effectuer des opérations lourdes

onStop ()

L'activité n'est plus visible. Libérez les ressources importantes, arrêtez les mises à jour, fermez les connexions à la base de données, désenregistrez les écouteurs et effectuez des sauvegardes persistantes.

Il court juste avant onDestroy () si l'activité doit être détruite, ou avant onRestart () si l'utilisateur revient.

onRestart ()

Elle n'est invoquée que si l'activité a été arrêtée et revient au premier plan. Elle permet de différencier une création complète d'un redémarrage en mémoire.

onDestroy ()

Dernier appel : Android détruit l'instance d'activité. Elle libère des ressources, termine des tâches et enregistre les éléments essentiels. Son exécution n'est pas toujours garantie (si le système arrête brutalement le processus, il n'est pas appelé).

États visuels et conceptuels d'une activité

Le cycle peut être divisé en états conceptuels :

Actif (repris) : Au premier plan, interactive et visible. Une seule activité peut être ainsi par application.
En pause : Partiellement visible, sans focus. L'utilisateur ne peut pas interagir, mais l'activité reste à l'écran (par exemple, si une boîte de dialogue apparaît).
Arrêté : Il n'est pas visible, mais reste en mémoire pour une réaction rapide si l'utilisateur revient.
Détruit: Instance supprimée. Si l'utilisateur revient, elle est recréée de zéro, sauf si l'état a été sauvegardé.

Transitions courantes : exemples pratiques en navigation

Lancement (application ouverte pour la première fois) : onCreate() → onStart() → onResume()
Démarrer une nouvelle activité : onPause() → onStop() dans l'activité précédente, onCreate() → onStart() → onResume() dans le nouveau
Retour à une activité arrêtée : onRestart() → onStart() → onResume()
Appuyez sur Accueil ou changez d’application : onPause() → onStop()
Rotation de l'écran: onPause() → onStop() → onDestroy() → [nouvelle instance] onCreate() → onStart() → onResume()

Ces flux sont courants et doivent être mis en œuvre pour éviter les surprises dans le comportement de l'application.

Gestion des changements de configuration : rotation, langue, ressources

Un changement de paramètre (rotation de l'écran, changement de langue, mode sombre, clavier physique) provoque Android détruire et recréer l'activité S'adapter au nouvel environnement implique de perdre les données stockées en mémoire si elles ne sont pas correctement gérées. Les mécanismes de préservation des informations sont les suivants :

onSaveInstanceState(Bundle): Pour sauvegarder les paires clé-valeur avec l'état de l'interface utilisateur (textes, positions, etc.) juste avant sa destruction. Elles sont récupérées dans onCreate() o onRestoreInstanceState().
VoirModèle: Permet de stocker les données et l'état de l'interface utilisateur qui doivent survivre aux modifications de configuration. Il s'agit de la solution moderne et recommandée.
mémoriserEnregistrable (Jetpack Compose) : permet aux variables de résister à la recomposition et aux redémarrages de l'interface.

Par exemple, si l’utilisateur remplit un formulaire et tourne le mobile, surSaveInstanceState enregistrera les champs saisis et les restaurera une fois l'écran recréé.

Différences principales : onSaveInstanceState, ViewModel et rememberSaveable

onSaveInstanceState(Bundle) : Pour les données simples (chaînes, nombres). Ne convient pas aux grandes collections ou aux objets complexes, car cela nécessite une sérialisation/désérialisation.
VoirModèle: Idéal pour les données moyennes ou complexes, car elles vivent aussi longtemps que l'activité ou le fragment existe (y compris les recréations dues aux changements de configuration).
mémoriserEnregistrable : Spécifique à Jetpack Compose, il stocke des variables pour résister aux recompositions et recréations de l'Activité.

Le choix dépend du type de données, de l'architecture et de la technologie (interface utilisateur traditionnelle ou Compose).

Gestion des activités d'arrière-plan et économie des ressources

Android peut mettre en pause, arrêter ou détruire les activités non visibles par optimiser la mémoire et la batterieLes activités d'arrière-plan sont plus susceptibles de disparaître si le système manque de ressources. Par conséquent, vous devez :

Libérez les capteurs, les caméras, les emplacements dans onPause() y onStop()
Enregistrer l'état de l'interface utilisateur avant de quitter l'écran
Évitez les tâches à long terme en dehors d'une activité visible

Navigation et communication entre les activités : intentions et résultats

Les activités communiquent et naviguent entre elles en utilisant Intentions, objets qui décrivent l'intention d'effectuer une action :

startActivity(Intent) : Démarrer une activité sans attendre de résultat.
startActivityForResult(Intent, int) : Démarre une activité en attendant qu'elle renvoie un résultat (utile pour sélectionner un contact, prendre une photo, etc.).

Le résultat est reçu en onActivityResult() avec un code d'état et les données renvoyées.

Intentions explicites et implicites : comment les utiliser et différences

Les Intentions ils peuvent être:

Explicite: Ils pointent vers une classe spécifique. Ils sont généralement utilisés pour naviguer dans l'application.
Implicite: Ils décrivent une action (par exemple, partager ou ouvrir un lien), permettant aux autres applications de répondre si elles peuvent gérer cette action.

Exemples:

Pour ouvrir votre propre activité : Intent(this, ConfigActivity::class.java)
Pour partager du texte par e-mail : Intent(Intent.ACTION_SEND) avec type text/plain

Modèles, meilleures pratiques et erreurs courantes dans le cycle de vie

Ne bloquez pas le thread de l'interface utilisateur en onCreate():Les opérations coûteuses (bases de données, réseau) doivent s'exécuter en arrière-plan.
Évitez d'enregistrer des données persistantes dans onPause(): Mieux vaut utiliser onStop() ou des mécanismes tels que ViewModel ou des bases de données.
Ne comptez pas uniquement sur onDestroy():Cette méthode n'est pas toujours invoquée si le système arrête brusquement le processus.
Utiliser LiveData et Observers pour garder l'interface utilisateur réactive aux modifications des données stockées dans le ViewModel.
Super doit toujours être appelé dans les rappels: Appel à super.onCreate() et d'autres pour éviter de briser les comportements par défaut du système.

Une segmentation correcte des tâches en fonction du cycle minimise les erreurs et maximise les performances de l'application.

Exemples de cas d'utilisation courants et de flux de cycle de vie

Ouvrez l'application pour la première fois : Séquence onCreate() → onStart() → onResume().
Activité partiellement visible : Une boîte de dialogue apparaît ; elle est exécutée uniquement onPause() mais c'est toujours visible.
Quitter et revenir à l'application : Après avoir appuyé sur Accueil et retour, onRestart() → onStart() → onResume() (sans revenir à onCreate()).
Rotation de l'appareil : L'activité est détruite et recréée ; elle est exécutée à nouveau. onCreate() après onDestroy().
Quitter définitivement (bouton retour) : onPause() → onStop() → onDestroy()

Ces flux sont courants et les développeurs doivent anticiper et tester chaque scénario pour éviter les fuites, les pertes de données ou les comportements incohérents.

Intégration avancée : cycle de vie, processus et gestion de la mémoire

Android peut interrompre des processus entiers pour libérer de la mémoire, notamment sur les appareils à faibles ressources. Le degré de vulnérabilité pouvant être détruit dépend de l'état :

État	Visible	Au point	Probabilité d'être détruit
Reprise (Actif)	Oui	Oui	Investissement
Démarré/Pause	Oui	Non	Médiathèque
Arrêté	Non	Non	Élevée
Détruit	Non	Non	Total

Pour cette raison, le système ne détruit jamais une activité individuellement : il tue le processus entier, et avec lui toutes les instances d'activités, de fragments et de services dans ce processus.

Comment enregistrer et restaurer correctement l'état de l'interface

Pour garantir que l'utilisateur ne perde pas d'informations pertinentes après des événements tels que la rotation, l'arrêt de la mémoire ou la navigation, combinez ces approches :

Utiliser onSaveInstanceState(Bundle) pour les données légères et temporaires (texte, sélections, défilement)
utilisation VoirModèle pour les données complexes et persistantes (listes, objets, résultats de réseau)
Utilise des bases de données ou un stockage local pour les informations à long terme ou les informations utilisateur

N'oubliez pas que pour restaurer correctement, onCreate() vous devriez vérifier si le Bundle est nul et ne lit les données que si elles contiennent des valeurs valides. onRestoreInstanceState() Elle n'est invoquée que si un élément est sauvegardé. Elle appelle toujours les méthodes. super afin de ne pas interrompre la restauration de la hiérarchie des vues par défaut.

Jetpack Compose et Lifecycle : intégration moderne

Avec Composition du Jetpack, le cycle de vie intègre celui des composables, dont les variables d'état peuvent survivre aux recompositions (avec remember) et les modifications de configuration (rememberSaveable). Utiliser:

rappeler pour les variables dont vous n'avez besoin que pendant la composition en cours
mémoriserEnregistrable pour la persistance dans la recréation de l'Activité
VoirModèle pour les données globales ou partagées sur plusieurs écrans ou composables

Erreurs courantes dans le cycle de vie des activités et conseils pour les éviter

Perte de données après rotation : Ne pas enregistrer correctement dans onSaveInstanceState() ou ViewModel. Solution : sauvegardez toujours l'essentiel.
Fuites de mémoire : Ne libérez pas les auditeurs et ne fermez pas les connexions dans onStop() y onDestroy().
Interface utilisateur bloquée lors du retour au premier plan : Laisser les processus lourds actifs après onPause() o onStop()Utilisez des threads ou des coroutines pour séparer les tâches coûteuses.
Crash après le retour à une activité : Échec de l'initialisation des ressources ou échec de la restauration d'un état cohérent selon la séquence du cycle.

Ressources recommandées pour approfondir le cycle de vie des activités

Guide officiel Android : Cycle de vie de l'activité
Laboratoire de code pratique : Étapes du cycle de vie de l'activité
Tutoriels sur GitHub à propos de ViewModel et gestion avancée des états dans Compose

Maîtriser le cycle de vie des activités est la première étape vers un développement Android professionnel. Des déclarations dans le manifeste à la gestion avancée des états et à la communication entre écrans, chaque détail compte. En utilisant efficacement les callbacks, les ViewModels et l'intégration Compose, vous garantissez des applications stables, rapides et prêtes à l'emploi, même sur des appareils aux ressources limitées.