Développez votre première application Android

Dans ce chapitre, nous allons voir comment fonctionne le cycle de vie d’une application Android. C'est un sujet très important qui est très spécifique au développement mobile. En effet, par rapport à un site web, une application sur un smartphone peut être dans différents états. Par exemple, elle peut être démarrée et affichée à l’écran, ou masquée mais toujours active en tâche de fond, affichée en mode portrait ou en mode paysage, etc. En tant que développeurs et développeuses, nous devons être capables de détecter ces différents états dans notre code afin de faire réagir en conséquence notre application.

Découvrez le cycle de vie d’une activité

Autre parallèle, lorsque votre réveil sonne le matin, vous passez de l'état endormi à l'état réveillé. Ensuite, lorsque vous vous levez puis vous préparez à aller travailler, vous passez de l'état réveillé à opérationnel. Tout au long d’une journée, vous passez d'un état à l'autre.

Sous Android, une activité passe également par différents états. Entre deux états, le système appelle certaines méthodes bien spécifiques, dans un ordre déterminé.

Voici les différents états dans lesquels une activité peut se trouver :

Par défaut, la méthodeonCreate()est automatiquement surchargée lorsque vous créez une nouvelle activité. Mais comme vous pouvez le voir sur le diagramme ci-dessus, il en existe d'autres, que nous allons découvrir maintenant.

La méthode  onCreate()

Cette méthode est appelée lorsque votre activité est créée par le système, et qu'elle entre dans l'étatCreated.

Généralement, les opérations effectuées dans cette méthode servent à mettre en place l'interface graphique et à initialiser les données qui seront utilisées par l’interface.

À ce stade, l'activité est créée, mais l'utilisateur ne la voit pas encore et ne peut pas interagir avec.

La méthode  onStart()

Cette méthode est appelée par le système lorsque l'activité entre dans l'étatStarted. L'interface graphique devient visible à l'utilisateur, mais il ne peut pas encore interagir avec les différents éléments.

La méthode  onResume()

Cette méthode est appelée lorsque l'activité entre dans l'étatResumed. L'activité devient entièrement opérationnelle. L'utilisateur peut utiliser l'application et cliquer sur les différents éléments graphiques.

L'application reste dans cet état tant qu'il n'y a pas d'interruption, comme par exemple la réception d'un appel téléphonique, le démarrage d'une nouvelle activité ou l'affichage d'une boîte de dialogue.

La méthode  onPause()

Cette méthode est appelée lorsque l'activité entre dans l'étatPaused. Une Activity passe par exemple dans l’étatPaused lorsqu’une  AlertDialog  est affichée : l’Activity sous-jacente est toujours visible, mais elle n’est pas au premier plan. Cette méthode est “l’inverse” de la méthode onResume()  : tout ce qui est initié dansonResume()doit être mis en pause dans cette méthode. Par exemple, une animation présentée à l'utilisateur est démarrée dansonResume()puis stoppée dansonPause().

Les traitements effectués dans cette méthode doivent être les plus courts possible.

La méthode  onStop()

Cette méthode est appelée lorsque l'activité entre dans l'étatStopped. Par exemple, lorsqu'une nouvelle activité est démarrée, l'activité appelante va se retrouver dans cet état. Elle n'est donc plus du tout visible à l'utilisateur. Les traitements liés à la mise à jour de l'interface graphique peuvent être arrêtés.

La méthode  onDestroy()

Cette méthode est appelée lorsque l'activité est arrêtée.

Séchez vos larmes, c'est normal :) La première fois, cela effraie toujours un peu. Nous allons mettre tout cela en pratique et vous irez tout de suite mieux.

Suivez le cycle de vie d’un fragment

Nous avons vu précédemment qu’un fragment correspond à une portion de l’interface. Il possède également son propre cycle de vie, et celui-ci est étroitement lié à celui de l’activité à laquelle il appartient. Entre deux états de son cycle de vie, le système appelle également certaines méthodes bien spécifiques qui s'enchaînent comme illustré ci-dessous selon l’état de l’application.

Vous remarquez certainement que certaines de ces méthodes, comme  onCreate()  ,  onStart  ou  onPause()  , ont le même nom que celles appelées par le système pour le cycle de vie d’une activité. Vous pouvez vous référer aux définitions données précédemment pour comprendre dans quel état se trouve le fragment lorsque ces méthodes sont appelées, en remplaçant bien sûr le terme activité par fragment. Définissons ci-dessous les méthodes spécifiques au cycle de vie d’un fragment.

La méthode  onAttach()

Cette méthode est appelée lorsqu’un fragment est ajouté à une activité. Elle est appelée une seule fois durant toute la durée de vie du fragment.

La méthode  onCreateView()

Cette méthode est appelée par le système afin de créer l’interface utilisateur correspondant au fragment. C’est en surchargeant cette méthode que nous indiquons au système la vue qu’il doit dessiner précisément à l’écran.

La méthode  onViewCreated()

Cette méthode est appelée immédiatement après que le système a rattaché la vue au fragment.

La méthode  onDestroyView()

À ce stade, la vue associée au fragment n’est plus affichée à l’écran. Mais l’objet fragment existe toujours. C’est dans cette fonction que, si besoin, vous allez pouvoir nettoyer des choses spécifiques à votre interface avant que le fragment soit complètement dans la fonction  onDestroy()  qui suit.

La méthode  onDetach()

Cette fonction est appelée après  onDestroy()  , et nous informe que le fragment a été dissocié de son activité parente.

Mise en application

Pour bien comprendre l'enchaînement des méthodes, je vous invite à toutes les surcharger (sauf  onCreate()  qui l'est déjà) dans votre activité et votre fragment, et d'afficher leur appel dans la console. Pour rappel, l'affichage d'une trace en Android s'effectue de la sorte :

Log.d(TAG, "onStart() called");

Comme TAG, vous pouvez utiliser ce que vous voulez. Personnellement, j’utilise mon prénom pour le retrouver facilement plus tard dans le LogCat !

En résumé

• Le cycle de vie d’une activité ou d’un fragment comporte différentes étapes qui se déroulent entre sa création, son affichage à l’écran et sa suppression.

• Les classes Activity et Fragment exposent des fonctions qui correspondent à ces différentes étapes. 

• En surchargeant ces fonctions, nous pouvons exécuter du code à des instants clés du cycle de vie. Par exemple en surchargeant la fonction onCreate  de la classe Activity pour initialiser son contenu, ou dans la fonction onDestroy  pour refermer une connexion à la base de donnée.

Cela fait beaucoup de fonctions et beaucoup de concepts à retenir, mais bonne nouvelle pour vous, au quotidien vous aurez surtout besoin de surcharger les fonctions  onCreate  (et  onCreateView  et  onViewCreated  pour un fragment),  onStart()  et  onResume()  . D’ailleurs vous l’avez déjà fait dans cette partie.

Dans la prochaine partie, nous allons dynamiser les questions et les réponses de notre quiz. Nous en profiterons pour nous  pencher sur une notion d'architecture logicielle : l'architecture MVVM.