1. Связь между Activity, Window и View

Что ж, изначально я просто хотел понять связь между ними, но потом не удержался и начал разбираться в процессе их вызова... В итоге я потратил на это два часа и понял лишь очень-очень маленькую часть. Действительно, те, кто копается в исходном коде на нижнем уровне, все мастера, например Лао Ло; я пока не на таком уровне. Ниже — резюме, основанное на моих собственных исследованиях и беглом просмотре исходного кода. Если что-то написано неверно, не стесняйтесь указать на это! Вот итоговая схема:

Анализ процесса:После того как Activity вызывает startActivity, в конечном итоге будет вызван метод attach. Затем в PolicyManager реализуется интерфейс Ipolicy, а следом — объект Policy. Затем вызывается метод makenewwindow(Context), который возвращает объект PhoneWindow. PhoneWindow — это подкласс Window. В этом PhoneWindow есть внутренний класс DecorView, который является корневым View всех окон приложения, то есть боссом View, напрямую управляющим тем, отображается ли Activity (цитируя оригинальные слова старого водителя..). Итак, внутри него есть LinearLayout, а внутри него — два FrameLayout, которые используются для размещения ActionBar и CustomView соответственно. Макет, который мы загружаем с помощью setContentView(), помещается в этот CustomView!

Позвольте мне обобщить взаимосвязь между этими тремя:Проведу натянутую аналогию: мы можем рассматривать эти три класса соответственно как: художника, холст и то, что нарисовано кистью; художник использует кисть (LayoutInflater.infalte), чтобы нарисовать узор, а затем наносит его на холст (addView)! В конце концов он отображается (setContentView)


2. Некоторые понятия Activity, Task и Back Stack

Далее давайте разберёмся с механизмом управления Activity в Android. Здесь участвуют два термина: Task и Back Stack!

Анализ понятий:

Наши приложения обычно состоят из нескольких Activity, и в Android нам предоставлено понятиеTask (задача), которое заключается в том, чтобы собрать несколько связанных Activity вместе, а затем выполнять навигацию и возврат между Activity! Конечно, этот Task — лишь понятие на уровне фреймворка, а структурой данных, реализующей Task в Android, являетсяBack StackЯ думаю, всем знаком стек как структура данных. В Java также есть класс коллекции Stack! Стек обладает следующими характеристиками:

Last In, First Out (LIFO). Обычные операции — push (помещение в стек) и pop (извлечение из стека). Самый верхний элемент называется вершиной стека, а самый нижний — дном стека.

И Back Stack в Android также обладает вышеперечисленными характеристиками. Вот как он управляет Activity:

При переходе к новому Activity это Activity помещается в стек и становится вершиной стека! Когда пользователь нажимает клавишу Back, Activity на вершине стека извлекается, и Activity, следующая сразу за ней, оказывается на вершине стека!

Давайте посмотрим на блок-схему, приведённую в официальной документации:

Анализ процесса:

В приложении есть три Activity: A1, A2 и A3. Когда пользователь нажимает значок приложения на Launcher или Home Screen, запускается главная Activity A1. Затем A1 открывает A2, а A2 открывает A3. В этот момент в стеке находятся три Activity, и эти три Activity по умолчанию находятся в одной задаче (Task). Когда пользователь нажимает Back, A3 извлекается, и в стеке остаются только A1 и A2. Повторное нажатие Back извлекает A2, и в стеке остаётся только A1. Продолжая нажимать Back, извлекается A1, задача удаляется, и программа завершается!

Затем в официальной документации я увидел ещё две диаграммы. Из любопытства я ещё раз прочитал объяснение, а затем обсудил его с ребятами в группе:

А ещё есть такое объяснение:

Затем я обобщил и сделал вывод:

Задача (Task) — это совокупность Activity; это концепция. На практике для хранения Activity используется Back Stack. Может существовать несколько задач, но одновременно только один стек находится на переднем плане, а остальные — в фоне! Так как же создаётся стек?

Ответ: Когда мы нажимаем значок на главном экране, чтобы открыть новое приложение, в этот момент создаётся новая задача! Например:
Мы открываем приложение Контакты, нажимая его значок. В этот момент создаётся новый Стек 1, и затем в него добавляются только что созданные Activity. Возможно, мы открываем страницу приложения SMS из приложения Контакты, но в этот момент новый стек не создаётся; вместо этого продолжается добавление в Стек 1. Это подход к пользовательскому опыту, продвигаемый Android, при котором переключение между разными приложениями может заставить пользователей чувствовать, будто они находятся в одном и том же приложении — очень бесшовный пользовательский опыт. Официальный термин для этого — «seamless» (бесшовное соединение).
—————— В этот момент, если мы нажмём клавишу Home и вернёмся на главный экран, Стек 1 уйдёт в фон. После этого у нас могут быть следующие две операции:
1) Нажмите клавишу меню (квадратную кнопку), щёлкните, чтобы открыть только что использованную программу, и Стек 1 возвращается на передний план! Или мы нажимаем значок Контакты на главном экране, чтобы открыть приложение; в этот момент новый стек также не создаётся, и Стек 1 возвращается на передний план!
2) Если в этот момент мы нажмём другой значок, чтобы открыть новое приложение, то будет создан новый Стек 2, Стек 2 выйдет на передний план, а Стек 1 продолжит оставаться в фоне;


3. Управление задачами

1) Перевод документа:

1) Перевод документа:


1) Перевод документа

1) Перевод документа

Продолжая работу с документацией, начиная с раздела «Managing Tasks» в документации, перевод выглядит так:

Как описано выше, Android добавляет недавно успешно запущенные Activity в одну и ту же задачу и управляет несколькими задачами и стеками возврата по принципу «первым пришёл — первым вышел». Пользователям не нужно беспокоиться о том, как Activity взаимодействуют с задачами или как они существуют в стеке возврата! Возможно, вы хотите изменить этот обычный подход к управлению. Например, вы можете захотеть, чтобы один из ваших Activity управлялся в новой задаче; или вы можете захотеть создавать только определённый Activity; или вы можете захотеть очистить все Activity в задаче, кроме корневого Activity, когда пользователь покидает задачу. Вы можете делать это и многое другое, просто изменяя соответствующие значения атрибутов <activity> в AndroidManifest.xml или передавая Intent со специальными флагами в startActivity() в коде, легко управляя Activity.

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

Атрибуты, которые можно использовать в <activity>, перечислены ниже:

  • FLAG_ACTIVITY_NEW_TASK
  • FLAG_ACTIVITY_CLEAR_TOP
  • FLAG_ACTIVITY_SINGLE_TOP

Основные флаги Intent, которые можно использовать:


2) taskAffinity и allowTaskReparenting

2) taskAffinity и allowTaskReparentingПо умолчанию в приложении,все Activity имеют Affinity

, что заставляет их принадлежать одной и той же Task. Это можно рассматривать как флаг того, находятся ли они в одной и той же Task. Однако каждая Activity может задать отдельную Affinity через атрибут taskAffinity в <activity>. Activity из разных приложений могут иметь одну и ту же Affinity, а разные Activity в одном приложении также могут быть настроены на разные Affinity. Атрибут Affinity действует в двух случаях:FLAG_ACTIVITY_NEW_TASK1) Когда объект Intent, запускающий Activity, содержит

2)allowTaskReparentingсвойство установлено в true. Если свойство allowTaskReparenting у Activity установлено в true, она может переместиться из одной Task (Task1) в другую Task (Task2) с той же Affinity (когда Task2 выводится на передний план). Если .apk-файл содержит несколько «приложений» с точки зрения пользователя, возможно, потребуется назначить этим Activity разные значения Affinity.


3)launchMode:

Четыре возможных значения. Режимы запуска — основа нашего исследования; мы подробно обсудим их ниже! Это:standard(по умолчанию),singleTop,singleTask,singleInstance


4) Очистка стека

Когда пользователь надолго покидает Task (текущая Task перемещается в фон), система очищает все Activity в этой Task, кроме Activity в нижней части стека. Таким образом, когда пользователь возвращается к Task, остаётся только начальная Activity этой Task. Мы можем изменить это поведение, изменив следующие свойства!

alwaysRetainTaskState: Если это свойство нижней Activity установлено в true, вышеописанная ситуация не произойдёт. Все Activity в Task будут сохраняться долгое время.

clearTaskOnLaunchЕсли это свойство нижней Activity установлено в true, то, как только пользователь покидает задачу, Activity в стеке задач будут очищены до тех пор, пока не останется только нижняя Activity. Это прямо противоположно alwaysRetainTaskState. Даже если пользователь покидает её лишь ненадолго, задача вернётся в исходное состояние (останется только нижняя Activity).

finishOnTaskLaunchПохоже на clearTaskOnLaunch, но действует на отдельную Activity, а не на всю задачу. Он может завершить любую Activity, включая Activity внизу стека. Если установлено в true, текущая Activity существует как часть задачи только для текущей сессии; когда пользователь выходит из Activity и возвращается, её больше не будет.


4. Подробное объяснение четырёх режимов запуска Activity:

Далее подробно объясним четыре режима загрузки: Это:standard(по умолчанию),singleTop,singleTask,singleInstanceЯ видел хорошо проиллюстрированную статью о режимах запуска на «Paozai Wangshang de Rizi» (сайт), она отличная и, возможно, её легче понять. Я сошлюсь на неё здесь:

Исходная ссылка:Подробное иллюстрированное объяснение режимов запуска Activity: standard, singleTop, singleTask и singleInstance

Оригинальная статья на английском:Разбираем launchMode Activity в Android: standard, singleTop, singleTask и singleInstanceКроме того, есть ещё одна статья, подробно объясняющая режимы загрузки:Подробное объяснение четырёх режимов запуска и атрибута taskAffinity у Activity в Android

Сначала посмотрим на сводную диаграмму:

Подробности о режимах:


режим standard:

Стандартный режим запуска, также режим запуска по умолчанию для Activity. Activity, запущенная в этом режиме, может быть создана несколько раз, то есть несколько экземпляров одной и той же Activity могут существовать в одной задаче, и каждый экземпляр будет обрабатывать один объект Intent. Если режим запуска Activity A — standard и A уже была запущена, повторный запуск Activity A изнутри A, то есть вызов startActivity(new Intent(this, A.class)), запустит ещё один экземпляр A поверх A, так что текущее состояние стека — A-->A.


Режим singleTop:

Если экземпляр Activity, запущенной в режиме singleTop, уже находится на вершине стека задач, то при повторном запуске этой Activity новый экземпляр не будет создан; вместо этого будет повторно использован экземпляр на вершине стека, и егоonNewIntent()метод будет вызван, чтобы передать объект Intent этому экземпляру. Например, если режим запуска A — singleTop и экземпляр A уже существует на вершине стека, то вызов startActivity(new Intent(this, A.class)) для повторного запуска A не создаст ещё один экземпляр A; вместо этого он повторно использует исходный экземпляр и вызовет метод onNewIntent() исходного экземпляра. На этом этапе в стеке задач по-прежнему только один экземпляр A. Если экземпляр Activity, запущенной в режиме singleTop, уже существует в стеке задач, но не на вершине, его поведение такое же, как в стандартном режиме, и будет создано несколько экземпляров.


Режим singleTask:

В системе допускается только один экземпляр Activity. Если экземпляр уже существует в системе, задача, содержащая этот экземпляр, будет перемещена наверх, а Intent будет отправлен через onNewIntent(). Если нет, будет создана новая Activity и помещена в подходящую задачу.

Вопрос, упомянутый в официальной документации:

Система создаст новую задачу и создаст экземпляр этой Activity как корень новой задачи. Для этого нам нужно задать taskAffinity. Результат после использования taskAffinity:



Режим singleInstance

Это гарантирует, что независимо от того, из какого Task запущено Activity, система создаст только один экземпляр Activity и добавит его наверх нового стека Task. То есть другие Activity, запущенные этим экземпляром, автоматически будут выполняться в другом Task. Когда экземпляр этого Activity будет запущен снова, существующий Task и экземпляр будут переиспользованы. И будет вызван метод onNewIntent() экземпляра, чтобы передать этому экземпляру Intent. Как и в случае singleTask, в любой момент времени в системе будет существовать только один такой экземпляр Activity.


5. Дополнение по Activity

Возможно, есть ещё кое-что об Activity, что пока не было рассмотрено, поэтому я оставил здесь место; всё пропущенное будет добавлено сюда! Сначала, следуя предложению участника группы Zhuhai-Kun, я также опубликую класс управления Activity из OSChina (Open Source China). Ага, сейчас выложу. Все могут использовать его прямо в своих проектах~

1) Класс управления Activity клиента 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) {    }
    }
}

Итоги этого раздела:

Хорошо, на этом всё для этого раздела. Содержание довольно неясное и сложное для понимания; пока просто имейте это в виду. Давайте в целом подведём итоги связанных операций планирования Task:

  • Нажмите кнопку Home, чтобы перевести предыдущий Task в фоновый режим.
  • Долгое нажатие кнопки Home отображает список недавно выполненных Task.
  • Коснитесь значка приложения на Launcher или Home Screen, чтобы запустить новый Task или вывести существующий Task на передний план.
  • При запуске Activity в режиме singleTask система ищет, существует ли уже подходящий Task. Если он существует, Task выводится на передний план для повторного использования. Если экземпляр запускаемой Activity уже существует в этом Task, все Activity, находящиеся выше этого экземпляра, очищаются, и экземпляр отображается пользователю. Если экземпляра запускаемой Activity в этом существующем Task нет, экземпляр запускается на вершине этого Task. Если такого Task не существует, создаётся новый Task, и экземпляр Activity в режиме singleTask запускается в этом новом Task.
  • При запуске Activity в режиме singleInstance система ищет, существует ли уже экземпляр этой Activity. Если он существует, Task, в котором находится этот экземпляр, выводится на передний план, и экземпляр Activity используется повторно (этот Task содержит только одну эту Activity). Если его нет, создаётся новый Task, и экземпляр Activity в режиме singleInstance запускается в этом новом Task.

Итак, на этом данный раздел заканчивается. Материал о Task и режимах запуска Activity довольно сложен. Ниже я приведу несколько источников, использованных при написании этой статьи; можете ознакомиться с ними самостоятельно~


Ссылки: