Notes d'étude Android 2.2 Cycle de vie des activités

Annuaire d'articles

1. Objectifs d'apprentissage
2. Apprendre de nouveaux cours

1. Objectifs d'apprentissage

Comprendre le diagramme du cycle de vie de l'activité
Méthodes de rappel du cycle de vie principal
Utilisez la classe de journal Log pour afficher des informations

2. Apprendre de nouveaux cours

(1) Cycle de vie de l'activité

1. Comprendre le cycle de vie de l'activité

À mesure que les utilisateurs parcourent, quittent et reviennent dans votre application, les instances d'activité de votre application passent d'un état à l'autre de leur cycle de vie. La classe Activity fournit de nombreux rappels qui permettent à l'activité de savoir qu'un certain état a changé : le système crée, arrête ou reprend une activité, ou le processus dans lequel se trouve l'activité est en cours de destruction.
Dans les méthodes de rappel du cycle de vie, vous pouvez déclarer le comportement de l'activité lorsque l'utilisateur quitte et réintègre l'activité. Par exemple, si vous créez un lecteur vidéo en streaming, vous souhaiterez peut-être mettre la vidéo en pause ou mettre fin à la connexion réseau lorsque l'utilisateur passe à une autre application. Lorsque l'utilisateur revient, vous pouvez vous reconnecter au réseau et permettre à l'utilisateur de continuer à lire la vidéo à partir du même emplacement. En d'autres termes, chaque rappel vous permet d'effectuer une tâche spécifique adaptée à un changement d'état donné. Exécuter le bon travail au bon moment et gérer les transitions de manière appropriée améliorera la robustesse et les performances de votre application. Par exemple, une bonne implémentation du rappel du cycle de vie peut aider à empêcher votre application de :
– Se bloquer lorsque l'utilisateur répond à un appel alors qu'il utilise l'application ou passe à une autre application.
– Consomme de précieuses ressources système lorsque l’utilisateur ne l’utilise pas activement.
– Perdez la progression de l’utilisateur lorsque celui-ci quitte l’application et y revient plus tard.
- Crash ou perte de la progression de l'utilisateur lorsque l'écran pivote entre paysage et portrait.

2. Schéma simplifié du cycle de vie de l'activité

Pour naviguer entre les différentes étapes du cycle de vie d' une activité, la classe Activity propose six méthodes de rappel principales : onCreate(), onStart(), onResume(), et . Chacune de ces méthodes de rappel est appelée lorsque l'activité entre dans un nouvel état.onPause()onStop()onDestroy()

(1) Que l'activité existe ou non

Le cycle de vie complet de l'activité onCreate()commence par la méthode et onDestroy()se termine par l'appel final de la méthode. Les ressources globales de l'Activité onCreate()sont définies dans la méthode, et onDestroy()les ressources sont finalement recyclées dans la méthode.

(2) Que l'activité soit visible ou non

L'activité est visible après le déclenchement onStart()de la méthode, mais peut ne pas pouvoir interagir avec l'utilisateur. La méthode est déclenchée lorsque l'Activité est complètement invisible onStop(). Lorsqu'il redevient visible, onRestart()la méthode est déclenchée en premier, puis onStart()la méthode. onStart()Les méthodes et onStop()méthodes peuvent être appelées plusieurs fois.

(3) Si l'activité peut être interagi avec ou non

L'activité est active entre la méthode onResume() et la méthode onPause() et peut interagir avec l'utilisateur à ce moment-là.

3. Priorité du processus Android

Le cycle de vie d'une application comprend toutes les étapes du processus dans le système Android, du démarrage à la fin, c'est-à-dire l'ensemble du processus Android, du démarrage à l'arrêt. La fin du cycle de vie d’une application Android n’est pas réalisée par le processus de candidature lui-même, mais dépend du système Android. Alors, quels critères d’importance le système utilise-t-il pour mettre fin aux applications Android ? Android divise tous les processus en cinq catégories de haut en bas en fonction des composants de l'application et de l'état d'exécution actuel des composants, comme le montre la figure suivante :

(2) Méthode de rappel du cycle de vie de l'activité

1. Méthode de rappel onCreate()

Vous devez implémenter ce rappel, qui est déclenché lorsque l'activité est créée pour la première fois par le système. Une fois l’activité créée, elle passe à l’état « Créé ». Dans la méthode onCreate(), vous effectuez une logique de démarrage d'application de base, qui ne doit se produire qu'une seule fois dans tout le cycle de vie de l'activité. Par exemple, une implémentation de onCreate() peut lier des données à une liste, associer une activité à un ViewModel et instancier certaines variables de portée de classe. Cette méthode reçoit le paramètre saveInstanceState, qui est un objet Bundle contenant l'état précédemment enregistré de l'activité. Si l'activité n'existait pas auparavant, la valeur de l'objet Bundle est nulle.
Si vous disposez d'un composant prenant en compte le cycle de vie associé à votre cycle de vie d'activité, le composant recevra l'événement ON_CREATE. Les méthodes annotées avec @OnLifecycleEvent sont appelées, permettant à votre composant prenant en compte le cycle de vie d'exécuter tout code de configuration requis pour l'état créé.

2. Méthode de rappel onStart()

-onCreate() Après avoir quitté, l'activité entrera dans l'état "Démarré" et sera visible par l'utilisateur. Ce rappel contient les derniers préparatifs avant que l'activité n'entre au premier plan et n'interagisse avec l'utilisateur.

3. Méthode de rappel onResume()

Le système appelle ce rappel avant que l'activité ne commence à interagir avec l'utilisateur. À ce stade, l'activité se trouve en haut de la pile d'activités et capture toutes les entrées de l'utilisateur. La plupart des fonctionnalités de base de l'application sont implémentées dans la méthode onResume().
Le rappel onResume() est toujours suivi du rappel onPause().

4. Méthode de rappel onPause()

Lorsqu'une activité perd le focus et entre dans l'état « Pause », le système appelle onPause(). Par exemple, cet état se produit lorsqu'un utilisateur appuie sur le bouton Précédent ou Applications récentes. Lorsque le système appelle onPause() pour votre activité, cela signifie techniquement que votre activité est encore partiellement visible, mais la plupart du temps, cela indique que l'utilisateur quitte l'activité et que l'activité passera bientôt à « arrêtée » ou « Statut « restauré ».
Si l'utilisateur souhaite que l'interface continue à se mettre à jour, l'activité à l'état « Pause » peut également continuer à mettre à jour l'interface. Par exemple, une activité qui affiche un écran de carte de navigation ou lit un lecteur multimédia serait une telle activité. Même si une telle activité perd son focus, les utilisateurs s'attendent toujours à ce que son interface continue à être mise à jour.
Vous ne devez pas utiliser onPause() pour enregistrer des données d'application ou d'utilisateur, passer des appels réseau ou effectuer des transactions de base de données. Pour plus d'informations sur l'enregistrement des données, voir Enregistrement et restauration de l'état d'activité.
Une fois l'exécution de onPause() terminée, le prochain rappel est onStop() ou onResume(), selon ce qui se passe après que l'activité entre dans l'état « Pause ».

5. Méthode de rappel onStop()

Lorsque l'activité n'est plus visible par l'utilisateur, le système appelle onStop(). Cela peut se produire lorsque l'activité est détruite, qu'une nouvelle activité est démarrée ou qu'une activité existante entre dans l'état « Reprise » et écrase l'activité arrêtée. Dans tous ces cas, l’activité arrêtée ne sera plus du tout visible.
Le prochain rappel système sera onRestart() (si l'activité réinteragit avec l'utilisateur) ou onDestroy() (si l'activité se termine complètement).

6. Méthode de rappel onRestart()

Ce rappel est appelé lorsque l'activité à l'état Arrêté est sur le point d'être redémarrée. onRestart() reprend l'activité à partir de l'état dans lequel elle se trouvait lorsqu'elle a été arrêtée.
Ce rappel est toujours suivi de onStart().

7. Méthode de rappel onDestroy()

Le système appelle ce rappel avant de détruire l'activité.
Ce rappel est le dernier rappel reçu par l'activité. Généralement, onDestroy() est implémenté pour garantir que toutes les ressources de l'activité sont libérées lorsque l'activité ou le processus contenant l'activité est détruit.

(3) Utilisez la classe Log pour générer des informations

Lors du débogage du code, si vous avez besoin d'afficher les informations de débogage, vous devez utiliser la classe android.util.Log d'Android, qui propose 5 méthodes courantes. Remarque : Lorsque vous utilisez différentes méthodes d'impression, elles comportent toutes des paramètres (String tag, String msg). tag représente l'étiquette des informations imprimées et msg représente les informations qui doivent être imprimées.

1. Méthode Log.v()

v : verbeux ; la couleur de sortie est noire et tout message sera affiché. Le v ici représente verbeux. L'utilisation habituelle est Log.v("","");

2. Méthode Log.d()

d : débogage ; la couleur de sortie est bleue. Seules les informations de débogage sont affichées, mais les informations de la couche supérieure sont affichées. Le filtrage peut être sélectionné via la balise Logcat de DDMS.

3. Méthode Log.i()

i : informations ; la couleur de sortie est verte et des informations générales sont affichées. Les informations de Log.v et Log.d ne seront pas sorties, mais les informations de i, w et e seront affichées.

4. Méthode Log.w()

w : avertissement ; la couleur de sortie est orange et des informations d'avertissement sont affichées. Généralement, nous devons faire attention à l'optimisation du code Android. En même temps, après l'avoir sélectionné, les informations Log.e seront également affichées.

5. Méthode Log.e()

e : erreur ; la couleur de sortie est rouge et seuls les messages d'erreur rouges sont affichés. Nous devons analyser attentivement pour trouver la cause de l'erreur.

(4) Démonstration de cas de méthode de rappel

1. Créez une application Android

Basé sur le modèle d'activité vide
Configurer les informations du projet
Cliquez sur le bouton [Terminer] pour terminer l'initialisation du projet

2. Fichier de ressources de chaîne

strings.xmlModifier app_nameles valeurs des variables dans le fichier et ajouter de nouvelles variablestest_life_cycle

3. Fichier de ressources de mise en page principal

Modifiez la disposition des contraintes en disposition linéaire et définissez les propriétés associées du contrôle d'étiquette.

4. Fonction d'implémentation de la classe d'interface principale

MainActivityDéfinir les constantes de balise dansTAG
Afficher un message de débogage dans les méthodes de rappel onCreate et onDestroy
Afficher un message de débogage dans les méthodes de rappel onStart et onStop
Afficher un message de débogage dans les méthodes de rappel onResume et onPause
Afficher un message de débogage dans la méthode de rappel onRestart (en train d'être complètement invisible⟹ \Longrightarrow⟹ complètement visible)
Afficher le code source de MainAcitivity

package net.xqf.lifecycle;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;
import android.util.Log;

public class MainActivity extends AppCompatActivity {
    
    

    private final static String TAG="life_cycle";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
    
    
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Log.d(TAG,"onCreate invoked");

    }

    @Override
    protected void onStart() {
    
    
        super.onStart();
        Log.d(TAG,"onStart invoked");
    }

    @Override
    protected void onResume() {
    
    
        super.onResume();
        Log.d(TAG,"onResume invoked");
    }

    @Override
    protected void onPause() {
    
    
        super.onPause();
        Log.d(TAG,"onPause invoked");
    }



    @Override
    protected void onStop() {
    
    
        super.onStop();
        Log.d(TAG, "ononStop invoked");
    }

    @Override
    protected void onRestart() {
    
    
        super.onRestart();
        Log.d(TAG,"onRestart invoked");
    }

    @Override
    protected void onDestroy() {
    
    
        super.onDestroy();
        Log.d(TAG, "onDestroy invoked");
    }
}

5. Ajouter un filtre de messages

Afin de mieux visualiser les informations de débogage de cette application, vous devez ajouter un filtre de messages. Créez le filtre de messages life_cycle_filter et enregistrez l'étiquette en tant que life_cycle

6. Démarrez l'application et affichez les journaux

Démarrez l'application et visualisez les messages dans LogCat (puis on change l'état de l'application : premier plan⟹ \Longrightarrow⟹background⟹ \Longrightarrow⟹ premier plan⟹ \Longrightarrow⟹ fermé)
Cliquez sur le bouton [Accueil] pour revenir au bureau de l'application mobile
À ce stade, la fenêtre de l'application est couverte par le bureau, affichez le message du journal
Cliquez sur le bouton [Aperçu] pour afficher la liste des applications récentes
L'application ouverte la plus récemment est [Life Cycle]
Cliquez sur l'application [Life Cycle] exécutée en arrière-plan et sa fenêtre reviendra au premier plan pour afficher les informations du journal.
Appuyer sur le bouton [Retour] ne peut en fait pas fermer l'application [Life Cycle]
Vous devez appuyer sur la touche [Aperçu], sélectionner l'application [Cycle de vie] et la faire glisser vers le haut pour fermer l'application.
À partir des informations du journal, nous pouvons voir l'architecture à trois niveaux