ActivityStackSupervisor，ActivityStack，ActivityRecord，TaskRecord的关系

在学习activity的启动流程的时候，经常会碰到这几个类的身影，特别是在AMS中，ActivityStackSupervisor和ActivityStack对象的调用链经常切来换去的，比叫绕。

下面这篇文章就是梳理了下这几个类的关系。

ActivityRecord、TaskRecord、ActivityStack以及Activity启动模式详解

1.简介

先来张简单的关系图：

 

ActivityStack、TaskRecord、ActivityRecord关系图.png

• 一个ActivityRecord对应一个Activity，保存了一个Activity的所有信息;但是一个Activity可能会有多个ActivityRecord,因为Activity可以被多次启动，这个主要取决于其启动模式。
• 一个TaskRecord由一个或者多个ActivityRecord组成，这就是我们常说的任务栈，具有后进先出的特点。
• ActivityStack则是用来管理TaskRecord的，包含了多个TaskRecord。

下面进入详细的代码分析，本文源码基于android 27。

2.代码分析

2.1 ActivityRecord

ActivityRecord，源码中的注释介绍：An entry in the history stack, representing an activity.
翻译：历史栈中的一个条目，代表一个activity。

    frameworks/base/services/core/java/com/android/server/am/ActivityRecord.java
    
    final class ActivityRecord extends ConfigurationContainer implements AppWindowContainerListener {

        final ActivityManagerService service; // owner
        final IApplicationToken.Stub appToken; // window manager token
        AppWindowContainerController mWindowContainerController;
        final ActivityInfo info; // all about me
        final ApplicationInfo appInfo; // information about activity's app
        
        //省略其他成员变量
        
        //ActivityRecord所在的TaskRecord
        private TaskRecord task;        // the task this is in.
        
        //构造方法，需要传递大量信息
        ActivityRecord(ActivityManagerService _service, ProcessRecord _caller, int _launchedFromPid,
                       int _launchedFromUid, String _launchedFromPackage, Intent _intent, String _resolvedType,
                       ActivityInfo aInfo, Configuration _configuration,
                       com.android.server.am.ActivityRecord _resultTo, String _resultWho, int _reqCode,
                       boolean _componentSpecified, boolean _rootVoiceInteraction,
                       ActivityStackSupervisor supervisor, ActivityOptions options,
                       com.android.server.am.ActivityRecord sourceRecord) {
        
        }
    }

• 实际上，ActivityRecord中存在着大量的成员变量，包含了一个Activity的所有信息。
• ActivityRecord中的成员变量task表示其所在的TaskRecord，由此可以看出：ActivityRecord与TaskRecord建立了联系。

startActivity()时会创建一个ActivityRecord：

    frameworks/base/services/core/java/com/android/server/am/ActivityStarter.java

    class ActivityStarter {
        private int startActivity(IApplicationThread caller, Intent intent, Intent ephemeralIntent,
                                  String resolvedType, ActivityInfo aInfo, ResolveInfo rInfo,
                                  IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
                                  IBinder resultTo, String resultWho, int requestCode, int callingPid, int callingUid,
                                  String callingPackage, int realCallingPid, int realCallingUid, int startFlags,
                                  ActivityOptions options, boolean ignoreTargetSecurity, boolean componentSpecified,
                                  com.android.server.am.ActivityRecord[] outActivity, TaskRecord inTask) {

            //其他代码略
            
            ActivityRecord r = new ActivityRecord(mService, callerApp, callingPid, callingUid,
                    callingPackage, intent, resolvedType, aInfo, mService.getGlobalConfiguration(),
                    resultRecord, resultWho, requestCode, componentSpecified, voiceSession != null,
                    mSupervisor, options, sourceRecord);
                    
            //其他代码略
        }
    }

2.2 TaskRecord

TaskRecord，内部维护一个ArrayList<ActivityRecord>用来保存ActivityRecord。

    frameworks/base/services/core/java/com/android/server/am/TaskRecord.java
    
    final class TaskRecord extends ConfigurationContainer implements TaskWindowContainerListener {
        final int taskId;       //任务ID
        final ArrayList<ActivityRecord> mActivities;   //使用一个ArrayList来保存所有的ActivityRecord
        private ActivityStack mStack;   //TaskRecord所在的ActivityStack
        
        //构造方法
        TaskRecord(ActivityManagerService service, int _taskId, ActivityInfo info, Intent _intent,
                   IVoiceInteractionSession _voiceSession, IVoiceInteractor _voiceInteractor, int type) {
            
        }
        
        //添加Activity到顶部
        void addActivityToTop(com.android.server.am.ActivityRecord r) {
            addActivityAtIndex(mActivities.size(), r);
        }
        
        //添加Activity到指定的索引位置
        void addActivityAtIndex(int index, ActivityRecord r) {
            //...

            r.setTask(this);//为ActivityRecord设置TaskRecord，就是这里建立的联系

            //...
            
            index = Math.min(size, index);
            mActivities.add(index, r);//添加到mActivities
            
            //...
        }

        //其他代码略
    }

• 可以看到TaskRecord中使用了一个ArrayList来保存所有的ActivityRecord。
• 同样，TaskRecord中的mStack表示其所在的ActivityStack。

startActivity()时也会创建一个TaskRecord：

    frameworks/base/services/core/java/com/android/server/am/ActivityStarter.java
    
    class ActivityStarter {

        private int setTaskFromReuseOrCreateNewTask(TaskRecord taskToAffiliate, int preferredLaunchStackId, ActivityStack topStack) {
            mTargetStack = computeStackFocus(mStartActivity, true, mLaunchBounds, mLaunchFlags, mOptions);

            if (mReuseTask == null) {
                //创建一个createTaskRecord，实际上是调用ActivityStack里面的createTaskRecord（）方法，ActivityStack下面会讲到
                final TaskRecord task = mTargetStack.createTaskRecord(
                        mSupervisor.getNextTaskIdForUserLocked(mStartActivity.userId),
                        mNewTaskInfo != null ? mNewTaskInfo : mStartActivity.info,
                        mNewTaskIntent != null ? mNewTaskIntent : mIntent, mVoiceSession,
                        mVoiceInteractor, !mLaunchTaskBehind /* toTop */, mStartActivity.mActivityType);

                //其他代码略
            }
        }
    }

2.3 ActivityStack

ActivityStack,内部维护了一个ArrayList<TaskRecord>，用来管理TaskRecord。

    frameworks/base/services/core/java/com/android/server/am/ActivityStack.java
    
    class ActivityStack<T extends StackWindowController> extends ConfigurationContainer implements StackWindowListener {

        private final ArrayList<TaskRecord> mTaskHistory = new ArrayList<>();//使用一个ArrayList来保存TaskRecord

        final int mStackId;

        protected final ActivityStackSupervisor mStackSupervisor;//持有一个ActivityStackSupervisor，所有的运行中的ActivityStacks都通过它来进行管理
        
        //构造方法
        ActivityStack(ActivityStackSupervisor.ActivityDisplay display, int stackId,
                      ActivityStackSupervisor supervisor, RecentTasks recentTasks, boolean onTop) {

        }
        
        TaskRecord createTaskRecord(int taskId, ActivityInfo info, Intent intent,
                                    IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
                                    boolean toTop, int type) {
                                    
            //创建一个task
            TaskRecord task = new TaskRecord(mService, taskId, info, intent, voiceSession, voiceInteractor, type);
            
            //将task添加到ActivityStack中去
            addTask(task, toTop, "createTaskRecord");

            //其他代码略

            return task;
        }
        
        //添加Task
        void addTask(final TaskRecord task, final boolean toTop, String reason) {

            addTask(task, toTop ? MAX_VALUE : 0, true /* schedulePictureInPictureModeChange */, reason);

            //其他代码略
        }

        //添加Task到指定位置
        void addTask(final TaskRecord task, int position, boolean schedulePictureInPictureModeChange,
                     String reason) {
            mTaskHistory.remove(task);//若存在，先移除
            
            //...
            
            mTaskHistory.add(position, task);//添加task到mTaskHistory
            task.setStack(this);//为TaskRecord设置ActivityStack

            //...
        }
        
        //其他代码略
    }

• 可以看到ActivityStack使用了一个ArrayList来保存TaskRecord。
• 另外，ActivityStack中还持有ActivityStackSupervisor对象，这个是用来管理ActivityStacks的。

ActivityStack是由ActivityStackSupervisor来创建的，实际ActivityStackSupervisor就是用来管理ActivityStack的，继续看下面的ActivityStackSupervisor分析。

2.4 ActivityStackSupervisor

ActivityStackSupervisor，顾名思义，就是用来管理ActivityStack的。

    frameworks/base/services/core/java/com/android/server/am/ActivityStackSupervisor.java
    
    public class ActivityStackSupervisor extends ConfigurationContainer implements DisplayListener {

        ActivityStack mHomeStack;//管理的是Launcher相关的任务

        ActivityStack mFocusedStack;//管理非Launcher相关的任务
        
        //创建ActivityStack
        ActivityStack createStack(int stackId, ActivityStackSupervisor.ActivityDisplay display, boolean onTop) {
            switch (stackId) {
                case PINNED_STACK_ID:
                    //PinnedActivityStack是ActivityStack的子类
                    return new PinnedActivityStack(display, stackId, this, mRecentTasks, onTop);
                default:
                    //创建一个ActivityStack
                    return new ActivityStack(display, stackId, this, mRecentTasks, onTop);
            }
        }

    }

• ActivityStackSupervisor内部有两个不同的ActivityStack对象：mHomeStack、mFocusedStack，用来管理不同的任务。
• ActivityStackSupervisor内部包含了创建ActivityStack对象的方法。

AMS初始化时会创建一个ActivityStackSupervisor对象。

2.5 总结

所以，实际上，他们的关系应该是这样的：

 

ActivityStack、TaskRecord、ActivityRecord、ActivityStackSupervisor关系图.png

3. 场景分析

下面通过启动Activity的代码来分析一下：

3.1 桌面

首先，我们看下处于桌面时的状态，运行命令：

adb shell dumpsys activity

结果如下：

ACTIVITY MANAGER ACTIVITIES (dumpsys activity activities)
Display #0 (activities from top to bottom):
  Stack #0:
  
  //中间省略其他...
  
    Task id #102
    
  //中间省略其他...
  
      TaskRecord{446ae9e #102 I=com.google.android.apps.nexuslauncher/.NexusLauncherActivity U=0 StackId=0 sz=1}
      Intent { act=android.intent.action.MAIN cat=[android.intent.category.HOME] flg=0x10000100 cmp=com.google.android.apps.nexuslauncher/.NexusLauncherActivity }
        Hist #0: ActivityRecord{54fa22 u0 com.google.android.apps.nexuslauncher/.NexusLauncherActivity t102}
          Intent { act=android.intent.action.MAIN cat=[android.intent.category.HOME] flg=0x10000100 cmp=com.google.android.apps.nexuslauncher/.NexusLauncherActivity }
          ProcessRecord{19c7c43 2203:com.google.android.apps.nexuslauncher/u0a22}

    Running activities (most recent first):
      TaskRecord{446ae9e #102 I=com.google.android.apps.nexuslauncher/.NexusLauncherActivity U=0 StackId=0 sz=1}
        Run #0: ActivityRecord{54fa22 u0 com.google.android.apps.nexuslauncher/.NexusLauncherActivity t102}

    mResumedActivity: ActivityRecord{54fa22 u0 com.google.android.apps.nexuslauncher/.NexusLauncherActivity t102}
    
//省略其他

实际上就是如下图所示的结构，这里的Stack #0就是ActivityStackSupervisor中的mHomeStack，mHomeStack管理的是Launcher相关的任务。

桌面下的状态.png

 

3.2 从桌面启动一个Activity

从桌面启动一个APP，然后运行上面的命令，为了节省篇幅，这里和后面就不贴结果了，直接放图了。

从桌面点击图标启动一个AActivity，可以看到，会多了一个Stack #1，这个Stack #1就是ActivityStackSupervisor中的mFocusedStack，mFocusedStack负责管理的是非Launcher相关的任务。同时也会创建一个新的ActivityRecord和TaskRecord，ActivityRecord放到TaskRecord中，TaskRecord则放进mFocusedStack中。

启动A.png

3.3 默认模式从A启动B

然后，我们从AActivity中启动一个BActivity,可以看到会创建一个新的ActivityRecord然后放到已有的TaskRecord栈顶。

默认（standerd）模式启动B.png

 

3.4 从A启动B创建新栈

如果我们想启动的BActivity在一个新的栈中呢，我们可以用singleInstance的方式来启动BActivity。singleInstance后面也会讲到。这种方式会创建一个新的ActivityRecord和TaskRecord，把ActivityRecord放到新的TaskRecord中去。

启动新Task.png

4. 流程分析

4.1 启动流程

这里对启动Activity过程中涉及到的ActivityStack、TaskRecord、ActivityRecord、ActivityStackSupervisor进行简单的分析，实际上一张时序图就可以看明白了。相关的代码可以看上面的内容。

Activity启动UML类图.png

简单总结：
1.startActivity时首先会创建一个ActivityRecord。
2.如果有需要，会创建一个TaskRecord，并把这个TaskRecord加入到ActivityStack中。
3.将ActivityRecord添加到TaskRecord的栈顶。

5. 启动模式

相信看完上面的介绍，现在再来看启动模式那是so easy了。

5.1 standerd

默认模式，每次启动Activity都会创建一个新的Activity实例。

比如：现在有个A Activity,我们在A上面启动B，再然后在B上面启动A，其过程如图所示：

standerd.png

5.2 singleTop

如果要启动的Activity已经在栈顶，则不会重新创建Activity，只会调用该该Activity的onNewIntent()方法。
如果要启动的Activity不在栈顶，则会重新创建该Activity的实例。

比如：现在有个A Activity,我们在A以standerd模式上面启动B，然后在B上面以singleTop模式启动A，其过程如图所示，这里会新创建一个A实例：

singleTop_A.png

如果在B上面以singleTop模式启动B的话，则不会重新创建B，只会调用onNewIntent()方法，其过程如图所示：

singleTop_B.png

 

5.3 singleTask

如果要启动的Activity已经存在于它想要归属的栈中，那么不会创建该Activity实例，将栈中位于该Activity上的所有的Activity出栈，同时该Activity的onNewIntent()方法会被调用。
如果要启动的Activity不存在于它想要归属的栈中，并且该栈存在，则会创建该Activity的实例。
如果要启动的Activity想要归属的栈不存在，则首先要创建一个新栈，然后创建该Activity实例并压入到新栈中。

比如：现在有个A Activity，我们在A以standerd模式上面启动B，然后在B上面以singleTask模式启动A，其过程如图所示：

singleTask.png

5.4 singleInstance

基本和singleTask一样，不同的是启动Activity时，首先要创建在一个新栈，然后创建该Activity实例并压入新栈中，新栈中只会存在这一个Activity实例。

比如：现在有个A Activity,我们在A以singleInstance模式上面启动B，其过程如图所示：

singleInstance.png

6.Intent的FLAG

另外，如果startActivity()时往Intent 中加入相应的标志来指定启动模式，这种方式的优先级会比在AndroidManifest中定义的优先级高;但是AndroidManifest中只能定义四种启动方式：standard、singleTop、singleTask、singleInstance，而Intent的flag则有很多种。具体的可以看看文档，我们这里看看部分flag：

• FLAG_ACTIVITY_NEW_TASK ：跟launchMode中的singleTask一样。
• FLAG_ACTIVITY_SINGLE_TOP ：跟launchMode中的singleTop一样。
• FLAG_ACTIVITY_CLEAR_TOP ：launchMode中没有对应的值，如果要启动的Activity已经存在于栈中，则将所有位于它上面的Activity出栈。singleTask默认具有此标记位的效果。

 

----------------------------------------------------------------

看完后我的理解就是：

ActivityManagerService这个对象（AMS）是在SystemServer这个进程中创建的，整个Android系统就这么一个对象，该对象会持有一个ActivityStackSupervisor对象（简称ASS），这个ASS管理所有的ActivityStack（不太清楚在整个系统中会有多少个ActivityStack对象），每个ActivityStack对象又管理着多个TaskRecord，也就是我们常说的任务栈，相同属性的activity（在AMS中就是对应的ActivityRecord）被同一个TaskRecord管理着。这里的TaskRecord就是在我们在桌面调出多任务的时候显示出来的每个页面，这个页面显示的就是某个TaskRecord里最上面的一个activity的界面。