01-Le_cycle_de_vie
CEFii
Created on June 21, 2023
Over 30 million people build interactive content in Genially.
Check out what others have designed:
STAGE2- LEVEL1-MISSION 2: ANIMATION
Presentation
LIBRARIES LIBRARIANS
Presentation
WORLD WILDLIFE DAY
Presentation
FOOD AND NUTRITION
Presentation
IAU@HLPF2019
Presentation
SPRING IN THE FOREST 2
Presentation
HUMAN RIGHTS
Presentation
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()
2. Cycle de vie des activités
Méthodes de cycle de vie principales :
- onStart()
2. Cycle de vie des activités
Méthodes de cycle de vie principales :
- onResume()
2. Cycle de vie des activités
Méthodes de cycle de vie principales :
- onPause()
2. Cycle de vie des activités
Méthodes de cycle de vie principales :
- onStop()
- onDestroy()
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()
- onCreateView()
- onViewCreated()
3. Cycle de vie des fragments
Différences entre le cycle de vie des activités et des fragments :
- onDestroyView()
- onDetach()
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.