1. La relation entre Activity, Window et View

Eh bien, au départ, je voulais juste comprendre la relation entre eux, mais ensuite je me suis impatienté et j'ai commencé à examiner leur processus d'appel... Au final, j'y ai passé deux heures et je n'ai compris qu'une très très petite partie. En effet, ceux qui creusent le code source au niveau le plus bas sont tous des maîtres, comme Lao Luo ; je n'ai pas encore ce niveau. Voici un résumé basé sur mes propres recherches et un bref coup d'œil au code source. Si quelque chose est mal écrit, n'hésitez pas à le signaler ! Voici le schéma récapitulatif :

Analyse du processus :Après que Activity appelle startActivity, il finira par appeler la méthode attach. Ensuite, une interface Ipolicy est implémentée dans PolicyManager, suivie d'un objet Policy. Puis la méthode makenewwindow(Context) est appelée, laquelle renvoie un objet PhoneWindow. PhoneWindow est une sous-classe de Window. Dans ce PhoneWindow se trouve une classe interne, DecorView, qui est la View racine de toutes les fenêtres d'application, c'est-à-dire le chef des Views, contrôlant directement si l'Activity est affichée (en citant les mots originaux du vieux conducteur..). Bon, ensuite à l'intérieur il y a un LinearLayout, et à l'intérieur de celui-ci il y a deux FrameLayouts, qui servent respectivement à contenir ActionBar et CustomView. La mise en page que nous chargeons avec setContentView() est placée dans ce CustomView !

Laissez-moi résumer la relation entre ces trois :Faisons une analogie tirée par les cheveux : nous pouvons considérer ces trois classes respectivement comme : un peintre, une toile et les choses peintes par le pinceau ; le peintre utilise un pinceau (LayoutInflater.infalte) pour dessiner un motif, puis le peint sur la toile (addView) ! Enfin, il est affiché (setContentView)


2. Quelques concepts de Activity, Task et Back Stack

Ensuite, comprenons le mécanisme de gestion des Activity dans Android. Cela implique deux termes : Task et Back Stack !

Analyse des concepts :

Nos applications sont généralement composées de plusieurs Activity, et dans Android, nous disposons d'un concept deTask (tâche), qui consiste à regrouper plusieurs Activity liées entre elles, puis à effectuer la navigation et le retour entre Activity ! Bien sûr, cette Task n'est qu'un concept au niveau du framework, et la structure de données qui implémente Task dans Android estPile de retourJe pense que tout le monde connaît la structure de données de pile. Il existe également une classe de collection Stack en Java ! La pile présente les caractéristiques suivantes :

Dernier entré, premier sorti (LIFO). Les opérations courantes sont push (empiler) et pop (dépiler). Celui tout en haut est appelé sommet de la pile, et celui tout en bas est appelé bas de la pile.

Et la pile de retour dans Android présente également les caractéristiques ci-dessus. Voici comment elle gère les Activity :

Lorsque l'on passe à une nouvelle Activity, cette Activity est empilée et devient le sommet de la pile ! Lorsque l'utilisateur appuie sur la touche Retour, l'Activity au sommet de la pile est dépilée, et l'Activity qui la suit immédiatement remonte au sommet de la pile !

Regardons un diagramme donné dans la documentation officielle :

Analyse du processus :

Dans l'application, il y a trois Activity : A1, A2 et A3. Lorsque l'utilisateur clique sur l'icône de l'application dans le Launcher ou l'écran d'accueil, l'Activity principale A1 démarre. Ensuite, A1 ouvre A2, et A2 ouvre A3. À ce stade, il y a trois Activity dans la pile, et ces trois Activity se trouvent par défaut dans la même tâche (Task). Lorsque l'utilisateur appuie sur Retour, A3 est dépilée, ne laissant que A1 et A2 dans la pile. Un nouvel appui sur Retour dépile A2, ne laissant que A1 dans la pile. Continuer d'appuyer sur Retour dépile A1, la tâche est supprimée, et le programme se ferme !

Ensuite, dans la documentation officielle, j'ai vu deux autres diagrammes. Par curiosité, j'ai relu l'explication, puis j'en ai discuté avec les personnes du groupe :

Et puis il y a cette explication :

Puis j'ai résumé et tiré une conclusion :

Une tâche est un ensemble d'activités ; c'est un concept. En pratique, la Back Stack est utilisée pour stocker les activités. Il peut y avoir plusieurs tâches, mais en même temps, une seule pile est au premier plan, et les autres sont en arrière-plan ! Alors, comment la pile est-elle créée ?

Réponse : lorsque nous touchons une icône sur l'écran d'accueil pour ouvrir une nouvelle application, une nouvelle tâche est créée à ce moment-là ! Par exemple :
Nous ouvrons l'application Contacts en touchant son icône. À ce moment-là, une nouvelle pile 1 est créée, puis les activités nouvellement créées y sont ajoutées. Peut-être ouvrons-nous la page de l'application SMS depuis l'application Contacts, mais à ce moment-là, une nouvelle pile n'est pas créée ; au lieu de cela, elle continue d'être ajoutée à la pile 1. C'est une approche d'expérience utilisateur prônée par Android, où le passage entre différentes applications peut donner aux utilisateurs l'impression d'être dans la même application — une expérience utilisateur très fluide. Le terme officiel pour cela est « seamless » (connexion transparente).
—————— À ce moment-là, si nous appuyons sur la touche Accueil et revenons à l'écran d'accueil, la pile 1 passe en arrière-plan. Nous pouvons alors effectuer les deux opérations suivantes :
1) Appuyez sur la touche menu (le bouton carré), cliquez pour ouvrir le programme que l'on vient d'ouvrir, et la pile 1 revient au premier plan ! Ou nous touchons l'icône Contacts sur l'écran d'accueil pour ouvrir l'application ; à ce moment-là, une nouvelle pile n'est pas créée non plus, et la pile 1 revient au premier plan !
2) Si nous touchons une autre icône pour ouvrir une nouvelle application à ce moment-là, alors une nouvelle pile 2 sera créée, la pile 2 passera au premier plan, et la pile 1 continuera de rester en arrière-plan ;


3. Gestion des tâches

1) Traduction du document :

1) Traduction du document :


1) Traduction du document

1) Traduction du document

En poursuivant avec la documentation, à partir de la section « Managing Tasks » (Gestion des tâches) dans les documents, la traduction est la suivante :

Comme décrit ci-dessus, Android ajoute les activités nouvellement démarrées avec succès à la même tâche et gère plusieurs tâches et piles de retour selon le mode « premier entré, premier sorti ». Les utilisateurs n'ont pas besoin de se soucier de la manière dont les activités interagissent avec les tâches ou de leur existence dans la pile de retour ! Vous souhaitez peut-être modifier cette approche de gestion normale. Par exemple, vous pouvez vouloir qu'une de vos activités soit gérée dans une nouvelle tâche ; ou vous pouvez vouloir instancier uniquement une certaine activité ; ou vous pouvez vouloir effacer toutes les activités de la tâche sauf l'activité racine lorsque l'utilisateur quitte la tâche. Vous pouvez faire ces choses ou plus en modifiant simplement les valeurs d'attribut pertinentes de <activity> dans AndroidManifest.xml, ou en passant un Intent avec des indicateurs spéciaux à startActivity() dans le code, pour gérer facilement les activités.

  • taskAffinity
  • launchMode
  • allowTaskReparenting
  • clearTaskOnLaunch
  • alwaysRetainTaskState
  • finishOnTaskLaunch

Les attributs que nous pouvons utiliser dans <activity> sont les suivants :

  • FLAG_ACTIVITY_NEW_TASK
  • FLAG_ACTIVITY_CLEAR_TOP
  • FLAG_ACTIVITY_SINGLE_TOP

Les principaux indicateurs Intent que vous pouvez utiliser sont :


2) taskAffinity et allowTaskReparenting

2) taskAffinity et allowTaskReparentingPar défaut, dans une application,toutes les activités ont une affinité

, ce qui les fait appartenir à la même tâche. Vous pouvez le voir comme un indicateur permettant de savoir si elles sont dans la même tâche. Toutefois, chaque activité peut définir une affinité distincte via l'attribut taskAffinity dans <activity>. Des activités issues d'applications différentes peuvent partager la même affinité, et différentes activités d'une même application peuvent également être définies avec des affinités différentes. L'attribut d'affinité prend effet dans deux cas :FLAG_ACTIVITY_NEW_TASK1) Lorsque l'objet Intent qui démarre une activité contient

2)allowTaskReparentingpropriété définie sur true. Si la propriété allowTaskReparenting d'une activité est définie sur true, elle peut se déplacer d'une tâche (Task1) vers une autre tâche (Task2) ayant la même affinité (lorsque Task2 est amenée au premier plan). Si un fichier .apk contient plusieurs « applications » du point de vue de l'utilisateur, vous devrez peut-être attribuer des valeurs d'affinité différentes à ces activités.


3)launchMode:

Quatre valeurs possibles. Les modes de lancement sont au cœur de notre recherche ; nous les examinerons en détail ci-dessous ! Ils sont :standard(par défaut),singleTop,singleTask,singleInstance


4) Vidage de la pile

Lorsque l'utilisateur quitte une tâche pendant longtemps (la tâche actuelle est déplacée en arrière-plan), le système efface toutes les activités de la tâche, sauf l'activité au bas de la pile. Ainsi, lorsque l'utilisateur revient à la tâche, seule l'activité initiale de cette tâche subsiste. Nous pouvons modifier ce comportement en modifiant les propriétés suivantes !

alwaysRetainTaskState: Si cette propriété de l'activité du bas est définie sur true, la situation ci-dessus ne se produira pas. Toutes les activités de la tâche seront conservées pendant longtemps.

clearTaskOnLaunchSi cette propriété de l'activité du bas est définie sur true, une fois que l'utilisateur quitte la tâche, les activités de la pile de tâches seront effacées jusqu'à ce qu'il ne reste que l'activité du bas. C'est exactement l'inverse de alwaysRetainTaskState. Même si l'utilisateur ne quitte que brièvement, la tâche reviendra à son état initial (seule l'activité du bas reste).

finishOnTaskLaunchSemblable à clearTaskOnLaunch, mais il agit sur une activité individuelle, et non sur toute la tâche. Il peut terminer n'importe quelle Activity, y compris l'activité au bas de la pile. Lorsqu'il est défini sur true, l'Activity actuelle n'existe en tant que partie de la tâche que pour la session en cours ; lorsque l'utilisateur quitte l'Activity et y revient, elle n'existera plus.


4. Explication détaillée des quatre modes de lancement de l'Activity :

Ensuite, expliquons en détail les quatre modes de chargement : Ce sont :standard(par défaut),singleTop,singleTask,singleInstanceJ'ai vu un article bien illustré sur les modes de lancement sur « Paozai Wangshang de Rizi » (un site web), il est excellent et peut-être plus facile à comprendre. Je vais le citer ici :

Lien original :Explication illustrée détaillée des modes de lancement de l'Activity : standard, singleTop, singleTask et singleInstance

Article original en anglais :Comprendre le launchMode de l'Activity Android : standard, singleTop, singleTask et singleInstanceDe plus, il existe un autre article expliquant en détail les modes de chargement :Explication détaillée des quatre modes de lancement et de l'attribut taskAffinity de l'Activity dans Android

Tout d'abord, regardons le diagramme récapitulatif :

Détails des modes :


mode standard :

Mode de lancement standard, également le mode de lancement par défaut des activités. Une activité démarrée dans ce mode peut être instanciée plusieurs fois, c'est-à-dire que plusieurs instances de la même activité peuvent exister dans la même tâche, et chaque instance traitera un objet Intent. Si le mode de lancement de l'Activity A est standard et que A a déjà été démarrée, démarrer à nouveau l'Activity A depuis A, c'est-à-dire appeler startActivity(new Intent(this, A.class)), lancera une autre instance de A au-dessus de A, donc l'état actuel de la pile est A-->A.


Mode singleTop :

Si une instance d'une Activity démarrée en mode singleTop existe déjà au sommet de la pile de tâches, alors, lorsqu'on démarre à nouveau cette Activity, une nouvelle instance ne sera pas créée ; à la place, l'instance au sommet de la pile sera réutilisée, et saonNewIntent()sera appelée pour transmettre l'objet Intent à cette instance. Par exemple, si le mode de lancement de A est singleTop et qu'une instance de A existe déjà au sommet de la pile, alors appeler startActivity(new Intent(this, A.class)) pour démarrer A à nouveau ne créera pas une autre instance de A ; à la place, cela réutilisera l'instance d'origine et appellera la méthode onNewIntent() de l'instance d'origine. À ce stade, il n'y a toujours qu'une seule instance de A dans la pile de tâches. Si une instance d'une activité démarrée en mode singleTop existe déjà dans la pile de tâches mais n'est pas au sommet, son comportement est le même que celui du mode standard, et plusieurs instances seront créées.


Mode singleTask :

Une seule instance d'Activity est autorisée dans le système. Si une instance existe déjà dans le système, la tâche contenant cette instance sera déplacée au sommet, et l'Intent sera envoyé via onNewIntent(). Sinon, une nouvelle Activity sera créée et placée dans une tâche appropriée.

Un problème mentionné dans la documentation officielle :

Le système créera une nouvelle tâche et instanciera cette Activity comme racine de la nouvelle tâche. Cela nous oblige à définir taskAffinity. Le résultat après avoir utilisé taskAffinity est :



Mode singleInstance

Cela garantit que, quelle que soit la Task à partir de laquelle l'Activity est démarrée, le système ne créera qu'une seule instance d'Activity et l'ajoutera au sommet d'une nouvelle pile de Tasks. C'est-à-dire que les autres activités démarrées par cette instance s'exécuteront automatiquement dans une autre Task. Lorsque l'instance de cette activité est démarrée à nouveau, la tâche et l'instance existantes seront réutilisées. Et la méthode onNewIntent() de l'instance sera appelée pour transmettre l'instance d'Intent à cette instance. Comme pour singleTask, à tout moment, il n'y aura qu'une seule instance de ce type d'Activity dans le système.


5. Complément sur Activity

Il y a peut-être encore des choses à propos d'Activity qui n'ont pas été couvertes, donc j'ai réservé un emplacement ici ; tout ce qui manque sera ajouté ici ! Tout d'abord, suivant la suggestion du membre du groupe Zhuhai-Kun, je vais aussi publier la classe de gestion d'Activity d'OSChina (Open Source China). Ouais, je la publie tout de suite. Tout le monde peut l'utiliser directement dans ses projets~

1) Classe de gestion d'Activity du client OSChina :

package net.oschina.app;

import java.util.Stack;

import android.app.Activity;
import android.app.ActivityManager;
import android.content.Context;


public class AppManager {
    
    private static Stack<Activity> activityStack;
    private static AppManager instance;
    
    private AppManager(){}
    /**
     * 单一实例
     */
    public static AppManager getAppManager(){
        if(instance==null){
            instance=new AppManager();
        }
        return instance;
    }
    /**
     * 添加Activity到堆栈
     */
    public void addActivity(Activity activity){
        if(activityStack==null){
            activityStack=new Stack<Activity>();
        }
        activityStack.add(activity);
    }
    /**
     * 获取当前Activity(堆栈中最后一个压入的)
     */
    public Activity currentActivity(){
        Activity activity=activityStack.lastElement();
        return activity;
    }
    /**
     * 结束当前Activity(堆栈中最后一个压入的)
     */
    public void finishActivity(){
        Activity activity=activityStack.lastElement();
        finishActivity(activity);
    }
    /**
     * 结束指定的Activity
     */
    public void finishActivity(Activity activity){
        if(activity!=null){
            activityStack.remove(activity);
            activity.finish();
            activity=null;
        }
    }
    /**
     * 结束指定类名的Activity
     */
    public void finishActivity(Class<?> cls){
        for (Activity activity : activityStack) {
            if(activity.getClass().equals(cls) ){
                finishActivity(activity);
            }
        }
    }
    /**
     * 结束所有Activity
     */
    public void finishAllActivity(){
        for (int i = 0, size = activityStack.size(); i < size; i++){
            if (null != activityStack.get(i)){
                activityStack.get(i).finish();
            }
        }
        activityStack.clear();
    }
    /**
     * 退出应用程序
     */
    public void AppExit(Context context) {
        try {
            finishAllActivity();
            ActivityManager activityMgr= (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
            activityMgr.restartPackage(context.getPackageName());
            System.exit(0);
        } catch (Exception e) {    }
    }
}

Résumé de cette section :

Bon, c'est tout pour cette section. Le contenu est assez obscur et difficile à comprendre ; contentez-vous d'en prendre connaissance pour l'instant. Résumons les opérations liées à l'ordonnancement global des Task :

  • Appuyez sur le bouton Accueil pour passer la Task précédente en arrière-plan.
  • Appuyez longuement sur le bouton Accueil pour afficher la liste des Tasks récemment exécutées.
  • Touchez une icône d'application sur le Launcher ou l'écran d'accueil pour démarrer une nouvelle Task, ou ramener une Task existante au premier plan.
  • Lors du démarrage d'une Activity en mode singleTask, le système cherche si une Task appropriée existe déjà. Si elle existe, la Task est amenée au premier plan pour être réutilisée. Si une instance de l'Activity à démarrer existe déjà dans cette Task, toutes les activités au-dessus de cette instance sont supprimées et l'instance est montrée à l'utilisateur. Si aucune instance de l'Activity à démarrer n'existe dans cette Task existante, une instance est démarrée au sommet de cette Task. Si cette Task n'existe pas, une nouvelle Task est démarrée, et une instance de l'Activity en mode singleTask est lancée dans cette nouvelle Task.
  • Lors du démarrage d'une Activity en mode singleInstance, le système cherche si une instance de cette Activity existe déjà. Si elle existe, la Task dans laquelle réside cette instance est amenée au premier plan et l'instance d'Activity est réutilisée (cette Task contient uniquement cette Activity). Si elle n'existe pas, une nouvelle Task est créée, et une instance de l'Activity en mode singleInstance est lancée dans cette nouvelle Task.

Très bien, c'est tout pour cette section. Le contenu sur les modes de chargement des Task et des Activity est assez complexe. Ci-dessous, je vais publier quelques références utilisées lors de la rédaction de cet article ; vous pouvez y jeter un œil par vous-même~


Références :