Full screen

Share

Show pages

Le cycle de vie
Want to make interactive content? It’s easy in Genially!

Over 30 million people build interactive content in Genially.

Check out what others have designed:

Transcript

Le cycle de vie

5. Bonnes pratiques et conseils

4. Gestion du cycle de vie avec Compose

3. Cycle de vie des fragments

2. Cycle de vie des activités

1. Introduction au cycle de vie

Objectifs : découvrez dans cette séquence de formation le cycle de vie dans les langages Kotlin et Jetpack compose.

Sommaire

Introduction au cycle de vie

Dans une application Android, le cycle de vie représente les différentes étapes par lesquelles une activité (ou un fragment) passe depuis sa création jusqu'à sa destruction. Chaque étape correspond à une méthode spécifique qui est appelée à un moment précis du cycle de vie. Comprendre et gérer le cycle de vie est essentiel pour garantir une utilisation optimale des ressources et offrir une expérience utilisateur fluide.

1. Introduction au cycle de vie

Définition du cycle de vie dans une application Android :

La gestion du cycle de vie est cruciale pour plusieurs raisons. Premièrement, elle permet d'optimiser l'utilisation des ressources en libérant celles qui ne sont plus nécessaires. Par exemple, en arrêtant l'exécution de tâches en arrière-plan lorsque l'activité est en pause ou en arrêt. Deuxièmement, la gestion du cycle de vie est essentielle pour préserver l'état de l'interface utilisateur (UI). Lorsqu'une activité ou un fragment passe d'un état à un autre, il est important de sauvegarder et de restaurer l'état de l'UI afin que l'utilisateur puisse reprendre là où il s'est arrêté, même après une rotation de l'écran ou un changement de configuration. Enfin, une bonne gestion du cycle de vie contribue à éviter les fuites de mémoire et à améliorer les performances globales de l'application.

1. Introduction au cycle de vie

Importance de la gestion du cycle de vie :

Kotlin facilite la gestion du cycle de vie grâce à ses fonctionnalités avancées telles que les propriétés observables, les fonctions d'extension et la nullabilité sûre. Il permet de réduire les risques d'erreurs liées au cycle de vie et rend le code plus concis et lisible. Quant à Jetpack Compose, il introduit un nouveau modèle de programmation déclaratif pour la création d'interfaces utilisateur, qui est conçu pour simplifier la gestion du cycle de vie. Dans Jetpack Compose, la composition est utilisée pour décrire l'UI en tant que fonction de l'état, ce qui permet de gérer automatiquement les mises à jour de l'UI en fonction des changements de l'état interne de l'application. Cela simplifie grandement la gestion du cycle de vie en éliminant le besoin de méthodes de cycle de vie traditionnelles telles que onCreate() ou onCreateView(). En utilisant Kotlin et Jetpack Compose ensemble, les développeurs peuvent bénéficier d'une gestion du cycle de vie plus simple, plus sûre et plus efficace.

1. Introduction au cycle de vie

Avantages de l'utilisation de Kotlin et Jetpack Compose :

Cycle de vie des activités

Voici dans un premier temps un schéma représentant le cycle de vie d'une activité sous Android. Le cycle débute en bas à gauche avec la méthode onCreate() et se termine en bas à droite avec la méthode onDestroy() :

2. Cycle de vie des activités

Méthodes de cycle de vie principales :

  • onCreate()
La méthode onCreate() est appelée lorsque l'activité est créée pour la première fois. C'est ici que vous effectuez les initialisations de base de votre activité, telles que l'inflation de la mise en page (layout) et la liaison des vues. C'est également l'endroit où vous pouvez restaurer l'état précédemment sauvegardé de l'activité, le cas échéant.Dans le module précédent, nous avons à cet endroit exécuté plusieurs composables pour afficher l'interface.

2. Cycle de vie des activités

Méthodes de cycle de vie principales :

  • onStart()
La méthode onStart() est appelée lorsque l'activité devient visible à l'utilisateur. À ce stade, l'activité est en cours de préparation pour interagir avec l'utilisateur, mais elle n'est pas encore au premier plan.

2. Cycle de vie des activités

Méthodes de cycle de vie principales :

  • onResume()
La méthode onResume() est appelée lorsque l'activité est sur le point d'entrer en interaction avec l'utilisateur. C'est ici que vous devez reprendre les mises à jour de l'interface utilisateur, les connexions aux services, les enregistrements des écouteurs, etc.

2. Cycle de vie des activités

Méthodes de cycle de vie principales :

  • onPause()
La méthode onPause() est appelée lorsque l'activité est en train de passer en arrière-plan et est sur le point de perdre le focus. C'est l'endroit où vous devez arrêter ou mettre en pause les mises à jour de l'interface utilisateur, les enregistrements des écouteurs, les connexions aux services, etc.

2. Cycle de vie des activités

Méthodes de cycle de vie principales :

  • onStop()
La méthode onStop() est appelée lorsque l'activité n'est plus visible à l'utilisateur. À ce stade, vous devez arrêter toutes les opérations qui ne sont plus nécessaires pour économiser des ressources.
  • onDestroy()
La méthode onDestroy() est appelée lorsque l'activité est en train d'être détruite. C'est ici que vous devez libérer les ressources, annuler les enregistrements, fermer les connexions, etc.Comme montré précédemment, Pour utiliser ces méthodes de cycle de vie dans une activité Kotlin, vous devez simplement les substituer (override) dans votre classe d'activité. Kotlin facilite cette tâche grâce à l'utilisation du mot-clé "override".Le mot-clé override est utilisé en programmation orientée objet pour indiquer qu'une méthode dans une classe enfant (ou dérivée) remplace une méthode avec la même signature (nom, type de retour, et paramètres) dans une classe parente (ou de base). En d'autres termes, il permet à la classe enfant de fournir une implémentation spécifique pour une méthode héritée de la classe parente.

2. Cycle de vie des activités

Méthodes de cycle de vie principales :

Cycle de vie des fragments

Voici dans un premier temps un schéma représentant le cycle de vie d'un fragment sous jetPack Compose. Le cycle débute en haut avec la méthode onCreate() et se termine en bas avec la méthode onDestroy() :

3. Cycle de vie des fragments

Différences entre le cycle de vie des activités et des fragments :

Les fragments ont un cycle de vie similaire à celui des activités, mais avec quelques différences importantes. Les fragments sont souvent utilisés pour construire des interfaces utilisateur modulaires et réutilisables au sein d'une activité. Voici les principales différences à connaître :

  • onAttach()
La méthode onAttach() est appelée lorsque le fragment est attaché à son activité hôte. C'est ici que vous pouvez effectuer des initialisations spécifiques au fragment, telles que la récupération des arguments passés à partir de l'activité.
  • onCreateView()
La méthode onCreateView() est appelée pour créer la vue du fragment. Vous devez ici gonfler (inflate) le layout du fragment et configurer les vues. C'est l'endroit idéal pour initialiser les composants d'interface utilisateur spécifiques au fragment.
  • onViewCreated()
La méthode onViewCreated() est appelée après que la vue du fragment a été créée. C'est ici que vous pouvez effectuer des opérations supplémentaires sur la vue, telles que la configuration des écouteurs.

3. Cycle de vie des fragments

Différences entre le cycle de vie des activités et des fragments :

  • onDestroyView()
La méthode onDestroyView() est appelée lorsque la vue du fragment est détruite. Vous pouvez effectuer ici des opérations de nettoyage, telle que la suppression des références aux vues.
  • onDetach()
La méthode onDetach() est appelée lorsque le fragment est détaché de son activité hôte. C'est ici que vous pouvez effectuer des nettoyages supplémentaires spécifiques au fragment.

3. Cycle de vie des fragments

Différences entre le cycle de vie des activités et des fragments :

En plus des méthodes mentionnées précédemment, les fragments ont également des méthodes de cycle de vie similaires à celles des activités, telles que onCreate(), onStart(), onResume(), onPause(), onStop() et onDestroy(). Ces méthodes sont utilisées de la même manière que pour les activités, avec des actions spécifiques au fragment.

3. Cycle de vie des fragments

Méthodes de cycle de vie principales des fragments :

Gestion du cycle de vie avec Compose

Prenons l'exemple d'un écran d'accueil pour une application de liste de tâches. L'objectif est de créer une interface utilisateur simple avec une liste de tâches affichée à l'utilisateur.

4. Gestion du cycle de vie avec Compose

Création d'un écran d'accueil avec Jetpack Compose :

Dans Jetpack Compose, la gestion des états et des événements se fait de manière déclarative. Jetpack Compose facilite la création d'états et la mise à jour de l'interface utilisateur en réponse aux événements. Prenons l'exemple d'un bouton qui permet d'ajouter une nouvelle tâche à la liste lorsque l'utilisateur appuie dessus avec la composable mutableStateOf().

4. Gestion du cycle de vie avec Compose

Gestion des états et des événements avec Jetpack Compose :

La composable rememberUpdatedState() est utilisée pour créer un état qui se met à jour uniquement lorsque la valeur passée en paramètre change. Cela est utile lorsque vous souhaitez mémoriser une valeur et réagir uniquement lorsque cette valeur est mise à jour.

4. Gestion du cycle de vie avec Compose

Gestion des états et des événements avec Jetpack Compose :

La composable LaunchedEffect() est utilisée pour exécuter une action lorsqu'une condition spécifique est satisfaite. Cela est couramment utilisé pour effectuer des opérations asynchrones ou gérer des effets de côté dans les composables.

4. Gestion du cycle de vie avec Compose

Gestion des états et des événements avec Jetpack Compose :

5- Exercices

Retour sur VirtualSchool

Vous venez de terminer cette séquence de formation ! Bravo à présent c'est à vous de jouer ! Rendez-vous dans VirtualSchool pour poursuivre l'aventure... Au programme exercice 1 intitulé : "Changer l'état d'une interface utilisateur"

Terminé !

Dans cet exemple, nous utilisons mutableStateOf pour créer un état newTaskTitle qui représente le titre de la nouvelle tâche. Nous utilisons le composant TextField pour permettre à l'utilisateur de saisir le titre de la nouvelle tâche, et nous mettons à jour l'état newTaskTitle en utilisant la fonction onValueChange.Lorsque l'utilisateur appuie sur le bouton "Add Task", nous pouvons ajouter la nouvelle tâche à la liste en utilisant une fonction de gestionnaire d'événements appropriée.

Dans cet exemple, nous utilisons la fonction HomeScreen pour créer l'interface utilisateur de l'écran d'accueil. Nous utilisons Column pour organiser les éléments verticalement. Nous affichons ensuite le titre de la liste de tâches à l'aide du composant Text, puis nous utilisons LazyColumn pour afficher la liste de tâches. Chaque élément de la liste est représenté par le composant TaskItem. Dans TaskItem, nous utilisons Row pour organiser les éléments horizontalement. Nous utilisons un composant Checkbox pour afficher l'état de complétion de la tâche, et nous affichons le titre de la tâche à l'aide du composant Text.

Dans cet exemple, nous utilisons la composable LaunchedEffect() pour effectuer une opération asynchrone (dans ce cas, une attente de 2000 millisecondes avec delay()). Une fois que l'opération asynchrone est terminée, nous mettons à jour l'état isLoading à false, ce qui déclenche la mise à jour de l'interface utilisateur. Si isLoading est true, nous affichons une CircularProgressIndicator pour indiquer que le chargement est en cours. Sinon, nous affichons simplement le texte "Loaded!" pour indiquer que le chargement est terminé.

Dans cet exemple, nous utilisons la composable rememberUpdatedState() pour créer un état count qui se met à jour uniquement lorsque la valeur de countState change. Cela signifie que chaque fois que le bouton est cliqué et que la valeur de countState est incrémentée, count est mis à jour et l'interface utilisateur est actualisée.

Next page

genially options