【Android 14源码分析】Activity启动流程-1

忽然有一天，我想要做一件事：去代码中去验证那些曾经被“灌输”的理论。
                  
                  
                                           – 服装学院的IT男
    本篇已收录于Activity短暂的一生系列
欢迎一起学习讨论Android应用开辟大概WMS
V：WJB6559
Q：707409814
  正文

由于篇幅原因，整个启动流程分为以下3篇进行分析：
Activity启动流程-1
Activity启动流程-2
Activity启动流程-3
Activity 的启动流程无论是 APP 开辟还是 FrameWork 开辟都是必须要认识的一个流程。
FrameWork 中有很多告急的流程都是在 Activity 启动过程中触发的，不过当前还是以分析 Activity 启动主流程为主，固然对于一些关键方法还是会着重先容，这样以后如果有碰到相干问题的修改可以通过这篇文章找到具体代码位置，然后根据具体的问题分析修改。
启动 Activity 的方式有很多，当前以在 Launcher 点击“电话”图标启动应用场景进行分析。
1. 整体先容

1.1 一级框图

对于Activity的启动流程来说，可以分为3个模块：
SourceActivity：实行 startActivity 方法的 Activity ，也就是发起请求的Activity ，当前是 Launcher 的 Activity 。
TargetActivity：被启动的 Activity 当前就是“电话”应用在清单文件配置的MainActivity
AMS: 不仅仅是指 AMS 这一个类，而是指在这个过程中 system_service 进程参与处置惩罚的相干类
举个例子，以在公司的工作流程来说， Launcher 模块的开辟，在处置惩罚一个 bug，但是涉及到了通话，那么他必要找到通讯组的同事来处置惩罚这个问题。但公司很大，他并不知道通讯模块是谁负责，更不知道这个问题必要交给通讯组具体的哪个同事处置惩罚，那么他只必要将自己的要求向公司向导（管理着）报告：必要通讯组的同事处置惩罚这个问题。
当前例子设计到 launcher 和通讯2个模块的开辟职员，还涉及到公司的管理者。在Activity 启动也是云云， 对于 SourceActivity、TargetActivity 来说他们并不知道对方模块的业务，以是这一流程必要AMS来做管理。
并且，这3个模块也对应3个进程，当前案例来说分别为：Launcher 进程，电话进程，system_service 进程。
   图中AMS 对 Launcher 多了一个返回箭头的原因是 Launcher 肯定是必要实行 pause 的，但实行 pause 的时机 Launcher 自身无法控制，只能由 AMS 控制。
  1.2 总体流程

这里有4个阶段，以4个颜色体现，同时还涉及到3个进程。
第一阶段：

• 
  
  • 由 Launcher 进程发起启动 Activity 的请求
    
  
  
• 
  
  • AMS 处置惩罚，创建对应的 ActivityRecord 和 Task ，并挂载到窗口层级树中
    
  
  
• 
  
  • AMS 触发 Launcher 的 pause 流程
    
  
  
• 
  
  • AMS 触发"电话"应用进程的创建
    
  
  

第二阶段：

• 
  
  • Launcher 实行完 pause
    
  
  
• 
  
  • pause 流程完成后触发 AMS 启动 TargetActivity
    
  
  

第三阶段：

• 
  
  • 创建应用进程
    
  
  
• 
  
  • 应用进程创建好后会向 AMS 进行绑定，并触发 AMS 启动 TargetActivity
    
  
  

第四阶段：

• 
  
  • AMS 触发 realStartActivityLocked 方法试图应用启动 Activity
    
  
  
• 
  
  • 如果还有 Activity 没有实行完 pause 逻辑，则 realStartActivityLocked 会 return
    
  
  
• 
  
  • 如果应用 Activity 都实行完了 pause ，则触发 TargetActivity 的启动，并将生命周期会实行到 onResume
    
  
  

注意：其中第2，3阶段险些是同时开始的，并且 ASM 通知 Launcher 实行 pause 和通过 Zygote 创建进程是异步操作，不知道各自实行的序次。
但是看的出来最终都是会实行到 realStartActivityLocked 方法来试图启动 TargetActivity ，为什么说是“试图启动”启动呢？
一共就有2种大概:

• 
  
  • completePause 先实行完
    
  
  
• 
  
  • 进程先创建完
    
  
  

假设第一种情况：
Launcher 先实行完 completePause 来到 ActivityTaskSupervisor::startSpecificActivity 方法，这个时间进程还没创建完毕，则不会实行 ActivityTaskSupervisor::realStartActivityLocked ，而是会再触发进程创建，固然之前已经触发过来，这次触发不会真的再创建进行了。
然后会由阶段三的流程创建好进程走到 ActivityTaskSupervisor::realStartActivityLocked ，在这个方法里会判断是不是实行完 pause 了，那当前这个情况肯定是满意的，
以是会触发启动 TargetActivity 。
假设第二种情况：
阶段三创建进程先实行完，走到 ActivityTaskSupervisor::realStartActivityLocked 方法，但是发现 pause 还没实行玩，以是就 return 了。
然后等 completePause 流程来到 ActivityTaskSupervisor::startSpecificActivity 方法时，这次发现进程已经创建好了，则一次实行后续逻辑触发启动 TargetActivity 。
也就是说不管阶段二，三谁先实行完都会试图启动 TargetActivity ，而乐成启动必须有2个条件：

• 
  
  • 进程创建完毕
    
  
  
• 
  
  • launcher实行完pause
    
  
  

也就说说这2个阶段后实行过来的流程才能正式启动 TargetActivity 。
2. 阶段一：桌面点击图标启动应用

2.1 流程概览

这一阶段调用比较简朴，堆栈如下：

整理后如下：

1. ItemClickHandler::onClick
2.     ItemClickHandler::onClickAppShortcut
3.         ItemClickHandler::startAppShortcutOrInfoActivity
4.             QuickstepLauncher::startActivitySafely
5.                 Launcher::startActivitySafely
6.                     AppLauncher::startActivitySafely
7.                         BaseQuickstepLauncher::getActivityLaunchOptions    -- 构建 Option 参数
8.                         Activity::startActivity  -- 共用启动Activity流程
9.                             Activity::startActivity
10.                                 Activity::startActivity
11.                                     Activity::startActivityForResult
12.                                         Instrumentation::execStartActivity
13.                                             ActivityTaskManagerService::startActivity -- 跨进程

复制代码

画成时序图：

其实我们正常通过 startActivity 通报 Intent 启动 Activity 的流程也是一样的，最终都会调到 Instrumentation::execStartActivity 然后开始跨进程与 AMS 通讯。
只不过这边多了一些 Launcher 自己的处置惩罚，这边只必要对 BaseQuickstepLauncher::getActivityLaunchOptions 有个印象即可，这个方法会构建 ActivityOptions 对象，包罗了一些启动参数，比如：远端动画的 RemoteAnimationAdapter 。
前面的流程就不看了，实行从 Activity::startActivityForResult 开始看代码流程。
2.2 SourceActivity 端处置惩罚

SourceActivity 发起启动 Activity 的逻辑相对简朴，无论哪种参数的 Activity::startActivity 方法，最终都是调到 Activity::startActivityForResult 方法。
然后在 Instrumentation 最后的处置惩罚，最后跨进程通报到 system_service 进程中。

1. # Activity.java
2.     public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
3.             @Nullable Bundle options) {
4.         if (mParent == null) {
5.             options = transferSpringboardActivityOptions(options);
6.             Instrumentation.ActivityResult ar =
7.                 mInstrumentation.execStartActivity(
8.                     this, mMainThread.getApplicationThread(), mToken, this,
9.                     intent, requestCode, options);
10.             ......
11.         }
12.         ......
13.     }
14. # Instrumentation.java
15.     public ActivityResult execStartActivity(
16.             Context who, IBinder contextThread, IBinder token, Activity target,
17.             Intent intent, int requestCode, Bundle options) {
18.         ......
19.             // 当前应用进程处理结束，开始传递给 ActivityTaskManagerService
20.             int result = ActivityTaskManager.getService().startActivity(whoThread,
21.                 who.getOpPackageName(), who.getAttributionTag(), intent,
22.                 intent.resolveTypeIfNeeded(who.getContentResolver()), token,
23.                 target != null ? target.mEmbeddedID : null, requestCode, 0, null, options);
24.             // 对跨进程启动的结果做check
25.             checkStartActivityResult(result, intent);
26.         ......
27.     }

复制代码

Instrumentation::checkStartActivityResult 这个方法有一些常见的报错，比如常见的未在 AndroidManifest.xml 注册 Activity 的报错就在这。

1. # Instrumentation
3.     public static void checkStartActivityResult(int res, Object intent) {
4.         if (!ActivityManager.isStartResultFatalError(res)) {
5.             return;
6.         }
8.         switch (res) {
9.             case ActivityManager.START_INTENT_NOT_RESOLVED:
10.             case ActivityManager.START_CLASS_NOT_FOUND:  // 未在AndroidManifest.xml注册
11.                 if (intent instanceof Intent && ((Intent)intent).getComponent() != null)
12.                     throw new ActivityNotFoundException(
13.                             "Unable to find explicit activity class "
14.                             + ((Intent)intent).getComponent().toShortString()
15.                             + "; have you declared this activity in your AndroidManifest.xml"
16.                             + ", or does your intent not match its declared <intent-filter>?");
17.                 throw new ActivityNotFoundException(
18.                         "No Activity found to handle " + intent);
19.             case ActivityManager.START_PERMISSION_DENIED:
20.                 throw new SecurityException("Not allowed to start activity "
21.                         + intent);
22.             case ActivityManager.START_FORWARD_AND_REQUEST_CONFLICT:
23.                 throw new AndroidRuntimeException(
24.                         "FORWARD_RESULT_FLAG used while also requesting a result");
25.             case ActivityManager.START_NOT_ACTIVITY:
26.                 throw new IllegalArgumentException(
27.                         "PendingIntent is not an activity");
28.             case ActivityManager.START_NOT_VOICE_COMPATIBLE:
29.                 throw new SecurityException(
30.                         "Starting under voice control not allowed for: " + intent);
31.             case ActivityManager.START_VOICE_NOT_ACTIVE_SESSION:
32.                 throw new IllegalStateException(
33.                         "Session calling startVoiceActivity does not match active session");
34.             case ActivityManager.START_VOICE_HIDDEN_SESSION:
35.                 throw new IllegalStateException(
36.                         "Cannot start voice activity on a hidden session");
37.             case ActivityManager.START_ASSISTANT_NOT_ACTIVE_SESSION:
38.                 throw new IllegalStateException(
39.                         "Session calling startAssistantActivity does not match active session");
40.             case ActivityManager.START_ASSISTANT_HIDDEN_SESSION:
41.                 throw new IllegalStateException(
42.                         "Cannot start assistant activity on a hidden session");
43.             case ActivityManager.START_CANCELED:
44.                 throw new AndroidRuntimeException("Activity could not be started for "
45.                         + intent);
46.             default:
47.                 throw new AndroidRuntimeException("Unknown error code "
48.                         + res + " when starting " + intent);
49.         }
50.     }

复制代码

3. 阶段一 : system_service 处置惩罚

3.1 流程概述

对于 system_service 来说，它收到了启动 Activity 的请求，那么它要做的就是启动 TargetActivity 。
要实现这个目标，我整理了大概要做以下几件事：

• 
  
  • 剖析请求参数
    
     
  
  
  
  • 想要启动 Activity 最最少得知道具体是哪个 Activity 吧，固然还有其他很多参数，比如是谁发起的请求，requestCode等等，这些参数都是应用端带过来的。system_service 的第一件事肯定是剖析这些参数，这些参数将被剖析存放在一个叫 Request 对象中。
    
  
  
• 
  
  • 处置惩罚窗口层级树相干逻辑
    
     
  
  
  
  • 虽然是启动 Activity ，但是肯定涉及到窗口操作，以是这一步也是必须的
    
  
  
• 
  
  • 触发 SourceActivity 实行pause 逻辑
    
     
  
  
  
  • 必要表现新的 TargetActivity ，那之前的 SourceActivity 肯定要实行 pause 逻辑的
    
  
  
• 
  
  • 触发创建进程
    
     
  
  
  
  • 当前场景是冷启动，那启动 TargetActivity 前必须要保证其所在的进程已经存在
    
  
  

在 Instrumentation::execStartActivity 里就开始触发跨进程通讯了，剩下的逻辑就在 system_service 进程中实行了。
这部分缩略版的的调用链如下：

1. ActivityTaskManagerService::startActivity
2.     ActivityTaskManagerService::startActivityAsUser
3.         ActivityTaskManagerService::startActivityAsUser
4.             ActivityStartController::obtainStarter
5.                 ActivityStarter::execute
6.                     ActivityStarter$Request::resolveActivity           -- 解析启动请求参数
7.                     ActivityStarter::executeRequest                    -- 3.3 创建ActivityRecord
8.                         ActivityStarter::startActivityUnchecked
9.                             ActivityStarter::startActivityInner        -- 3.4 关键函数startActivityInner
10.                                 ActivityStarter::getOrCreateRootTask   -- 3.4.1 创建或者拿到Task               
11.                                 ActivityStarter::setNewTask            -- 3.4.2 将Task与activityRecord 绑定
12.                                 Task::moveToFront                       --3.4.3 移动Task到栈顶
13.                                 RootWindowContainer::resumeFocusedTasksTopActivities    --3.4.4 显示Activity
14.                                     Task::resumeTopActivityUncheckedLocked
15.                                         Task::resumeTopActivityInnerLocked
16.                                             TaskFragment::resumeTopActivity      --  显示顶层Activity
17.                                                 TaskDisplayArea::pauseBackTasks                   -- pause LauncherActivity
18.                                                 ActivityTaskManagerService::startProcessAsync     -- 创建“电话”进程

复制代码

时序图：

流程来到 ActivityTaskManagerService::startActivity ，经过2次简朴的跳转会实行 ActivityTaskManagerService::startActivityAsUser 方法。
这个方法比较告急，在这里会构建一个 ActivityStartController ，根据类名可以知道这个类是控制 Activity 启动。
3.2 启动请求参数的构建

代码如下：

1. # ActivityTaskManagerService
3.     private int startActivityAsUser(IApplicationThread caller, String callingPackage,
4.             @Nullable String callingFeatureId, Intent intent, String resolvedType,
5.             IBinder resultTo, String resultWho, int requestCode, int startFlags,
6.             ProfilerInfo profilerInfo, Bundle bOptions, int userId, boolean validateIncomingUser) {
7.             ......
8.             // 返回的是ActivityStartController
9.             return getActivityStartController().obtainStarter(intent, "startActivityAsUser")
10.                 .setCaller(caller)
11.                 .setCallingPackage(callingPackage)
12.                 .setCallingFeatureId(callingFeatureId)
13.                 .setResolvedType(resolvedType)
14.                 .setResultTo(resultTo)
15.                 .setResultWho(resultWho)
16.                 .setRequestCode(requestCode)
17.                 .setStartFlags(startFlags)
18.                 .setProfilerInfo(profilerInfo)
19.                 .setActivityOptions(bOptions)
20.                 .setUserId(userId)
21.                 .execute();
22.     }
24.     ActivityStartController getActivityStartController() {
25.         return mActivityStartController;
26.     }

复制代码

ActivityStartController:btainStarter 返回的是 ActivityStarter 对象。
而 ActivityStarter 这个类名看着就是处置惩罚启动 Activity 的一个类，它做的是就是剖析调用者通报的参数，构建出一个 Request 然后开始实行后续的启动 Activity 逻辑。

1. # ActivityStartController
2.     // 返回ActivityStarter
3.     ActivityStarter obtainStarter(Intent intent, String reason) {
4.         return mFactory.obtain().setIntent(intent).setReason(reason);
5.     }

复制代码

以是在 ActivityTaskManagerService::startActivityAsUser 方法中的 build 模式，其实是对 ActivityStarter 对象做构建，最终调用其 execute 方法。
在内容最终实行了 ActivityStarter::executeRequest 方法，下面只以 setCallingPackage 这一个方法看一下是怎么把参数设置到 Request 中的。

1. # ActivityStarter
2.     // 启动Activity的请求
3.     Request mRequest = new Request();
4.     // 设置调用者包名
5.     ActivityStarter setCallingPackage(String callingPackage) {
6.         mRequest.callingPackage = callingPackage;
7.         return this;
8.     }
9.     // 设置ActivityInfo
10.     ActivityStarter setActivityInfo(ActivityInfo info) {
11.         mRequest.activityInfo = info;
12.         return this;
13.     }
14.     int execute() {
15.         ......
16.         // 如果 mRequest 中没有 Activity 相关信息
17.         if (mRequest.activityInfo == null) {
18.             // 解析请求数据
19.             mRequest.resolveActivity(mSupervisor);
20.         }
21.         ......
22.         // 执行启动Activity请求
23.         res = executeRequest(mRequest);
24.         ......
25.     }

复制代码

build 模式会把参数设置到 mRequest 中，但是并没有看到调用 ActivityStarter::setActivityInfo 以是在实行 ActivityStarter::execute 的时间 “mRequest.activityInfo”是 null 。
以是这里又分2步：

• 
  
  • 剖析获取 activityInfo
    
  
  
• 
  
  • 实行后续启动逻辑
    
  
  

3.2.1 activityInfo 的剖析

1. ActivityStarter$Request
3.     ResolveInfo resolveInfo;
4.     ActivityInfo activityInfo;
6.     void resolveActivity(ActivityTaskSupervisor supervisor) {
7.         ......
8.             // 解析resolveInfo
9.             resolveInfo = supervisor.resolveIntent(intent, resolvedType, userId,
10.                 0 /* matchFlags */,
11.                 computeResolveFilterUid(callingUid, realCallingUid, filterCallingUid),
12.                 realCallingPid);
13.             ......
14.             // 解析activityInfo
15.             activityInfo = supervisor.resolveActivity(intent, resolveInfo, startFlags,
16.                     profilerInfo);
17.             ......
18.     }

复制代码

  TargetActivity 所在的进程包名和 TargetActivity 的完整路径都在 activityInfo 中，这个剖析方法也是一个核心点，当前分析主流程就不细看了。
  如今 mRequest 中就包罗了启动 TargetActivity 的所有数据，就可以继续后面的启动流程了。
3.3 创建ActivityRecord

ActivityStarter::executeRequest 是一个必要注意的方法，因为内部会创建 ActivityRecord 对象，而这个 ActivityRecord 对象持有 token ，这个 token 就是以后分析其他逻辑一直会出现的 token 。也可以说是 system_service 中一个 Activity 的唯一标识。
应用进程中的 Activity 在 AMS 的代表就是 ActivityRecord 。

1. # ActivityStarter
3.   private int executeRequest(Request request) {
4.         ......
5.         // 包名在这
6.         ActivityInfo aInfo = request.activityInfo;
7.         ResolveInfo rInfo = request.resolveInfo;
8.         ......
9.         if (err == ActivityManager.START_SUCCESS) {
10.             // 重点* 1. 打印创建 ActivityRecord 日志
11.             request.logMessage.append("START u").append(userId).append(" {")
12.                     .append(intent.toShortString(true, true, true, false))
13.                     .append("} with ").append(launchModeToString(launchMode))
14.                     .append(" from uid ").append(callingUid);
15.             if (callingUid != realCallingUid
16.                     && realCallingUid != Request.DEFAULT_REAL_CALLING_UID) {
17.                 request.logMessage.append(" (realCallingUid=").append(realCallingUid).append(")");
18.             }
19.         }
20.         ......
21.         // 重点* 2. 构造出一个ActivityRecord
22.         final ActivityRecord r = new ActivityRecord.Builder(mService)
23.                 .setCaller(callerApp)
24.                 .setLaunchedFromPid(callingPid)
25.                 .setLaunchedFromUid(callingUid)
26.                 .setLaunchedFromPackage(callingPackage)
27.                 .setLaunchedFromFeature(callingFeatureId)
28.                 .setIntent(intent)
29.                 .setResolvedType(resolvedType)
30.                 .setActivityInfo(aInfo)
31.                 .setConfiguration(mService.getGlobalConfiguration())
32.                 .setResultTo(resultRecord)
33.                 .setResultWho(resultWho)
34.                 .setRequestCode(requestCode)
35.                 .setComponentSpecified(request.componentSpecified)
36.                 .setRootVoiceInteraction(voiceSession != null)
37.                 .setActivityOptions(checkedOptions)
38.                 .setSourceRecord(sourceRecord)
39.                 .build();
40.         ......
41.         // 重点* 3. 继续执行startActivityUnchecked
42.         mLastStartActivityResult = startActivityUnchecked(r, sourceRecord, voiceSession,
43.                 request.voiceInteractor, startFlags, true /* doResume */, checkedOptions,
44.                 inTask, inTaskFragment, restrictedBgActivity, intentGrants);
45.         ......
46.   }

复制代码

3个注意点：

• 
  
  • 虽然是个日记，但是也很关键，一般分析日记看启动了哪个 Activity 就搜“START u” ，打印的地方就在这。另外发现 U 版本上这一块还做了改变。
    
  
  
• 
  
  • 构建出一个 ActivityRecord 对象
    
  
  
• 
  
  • 继续主流程
    主要看第二点 ActivityRecord 是怎么创建的。
    
  
  

1. # ActivityRecord
2.     private ActivityRecord(ActivityTaskManagerService _service, ......) {
3.             // 调用父类，创建 Token
4.             super(_service.mWindowManager, new Token(), TYPE_APPLICATION, true,
5.                 null /* displayContent */, false /* ownerCanManageAppTokens */);
6.             ......
7.             packageName = info.applicationInfo.packageName;
8.             .....
9.         }

复制代码

这里的重点其实就是创建了一个匿名 Token 然后通报到了父类的构建方法， ActivityRecord 的父类是 WindowToken 。

1. # WindowToken
3.     protected WindowToken(WindowManagerService service, IBinder _token, int type,
4.             boolean persistOnEmpty, DisplayContent dc, boolean ownerCanManageAppTokens) {
5.         this(service, _token, type, persistOnEmpty, dc, ownerCanManageAppTokens,
6.                 false /* roundedCornerOverlay */, false /* fromClientToken */, null /* options */);
7.     }
9.     protected WindowToken(WindowManagerService service, IBinder _token, int type,
10.             boolean persistOnEmpty, DisplayContent dc, boolean ownerCanManageAppTokens,
11.             boolean roundedCornerOverlay, boolean fromClientToken, @Nullable Bundle options) {
12.         super(service);
13.         // token 赋值
14.         token = _token;
15.         windowType = type;
16.         mOptions = options;
17.         ......
18.         if (dc != null) {
19.             // 挂载到窗口树，
20.             dc.addWindowToken(token, this);
21.         }
22.     }

复制代码

将 ActivityRecord 创建的匿名 保存在了 token 对象，这个 token 就是 Activity 在 system_service 里唯一标识符。
   平凡的 WindowToken 在这里会挂载的窗口层级树，但是 DisplayContent::addWindowToken 方法内部对 ActivityRecord 做了判断。也就是说 ActivityRecord 刚创建好后是不会挂载到窗口树上的，当前流程后面是要先容 ActivityRecord 是怎么挂载到层级树上的。
  ActivityRecord 创建好后继续走主流程，根据前面的分析下一步是实行 ActivityStarter::startActivityUnchecked 不过这个方法也没做啥，主要是调用了 ActivityStarter::startActivityInner ，这个方法是流程的关键点。
3.4 窗口层级树处置惩罚

ActivityStarter::startActivityInner 是 Activity 启动流程最告急的函数之一，这里涉及到【窗口层级树】相干知识，上一末节说了 ActivityRecord 创建好后并不会和 WindowToken 一样挂载到层级树中，而是必要单独处置惩罚，本末节就是看这一块是怎样处置惩罚的。
先看看正常在 Launcher 界面时和启动“电话”后的层级树对比。

这里首先多了3个东西：

• 
  
  • Task
    
  
  
• 
  
  • 上一步创建的 ActivityRecord
    
  
  
• 
  
  • WindowState。
    
  
  

另外这个 Task 还移动到了DefaultTaskDisplayArea的最顶部,这里涉及到的操作如下：

• 
  
  • 创建 Task
    
  
  
• 
  
  • ActivityRecord 挂在到这个 Task 下
    
  
  
• 
  
  • 将这个 Task 移动到最上面
    
  
  

至于最下面的那个 546fce2 为什么是 WindowState 对象，又是怎么挂在到 ActivityRecord 上的，这个属于窗口表现第一步-addWindow流程当前就不单独分析了。
继续看主流程代码：

1. # ActivityStarter
3.     // The task that the last activity was started into. We currently reset the actual start
4.     // activity's task and as a result may not have a reference to the task in all cases
5.     private Task mTargetTask;
7.     int startActivityInner(final ActivityRecord r, ActivityRecord sourceRecord,
8.             IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
9.             int startFlags, boolean doResume, ActivityOptions options, Task inTask,
10.             TaskFragment inTaskFragment, boolean restrictedBgActivity,
11.             NeededUriGrants intentGrants) {
12.             ......
13.             // computeTargetTask内部会根据具体条件返回Task（比如标志位FLAG_ACTIVITY_NEW_TASK 就需要重新创建Task   ）
14.             // 这里reusedTask为 null，因为是新启动的应用，所以computeTargetTask也找不到task，最终也为null
15.             
16.             final Task targetTask = reusedTask != null ? reusedTask : computeTargetTask();
17.             // 那么newTask为true， 表示需要新建一个task
18.             final boolean newTask = targetTask == null;
19.             // 同样为null
20.             mTargetTask = targetTask;
21.             ......
22.             if (mTargetRootTask == null) {
23.                 // 重点* 1. 创建Task   23
24.                 mTargetRootTask = getOrCreateRootTask(mStartActivity, mLaunchFlags, targetTask,
25.                         mOptions);
26.             }
27.             if (newTask) {
28.                 // taskToAffiliate 为null
29.                 final Task taskToAffiliate = (mLaunchTaskBehind && mSourceRecord != null)
30.                         ? mSourceRecord.getTask() : null;
31.                 // 重点* 2. 将需要启动的ActivityRecord与 新创建的Task 进行绑定
32.                 setNewTask(taskToAffiliate);
33.             } else if (mAddingToTask) {
34.                 addOrReparentStartingActivity(targetTask, "adding to task");
35.             }
37.             if (!mAvoidMoveToFront && mDoResume) {
38.                 // 重点* 3. 移动到栈顶
39.                 mTargetRootTask.getRootTask().moveToFront("reuseOrNewTask", targetTask);
40.                 ......
41.             }
42.             ......
43.             if (mDoResume) {
44.                 ......
45.                 // 重点*4. task 处理完后，需要将task顶部的Activity显示（resume）
46.                 // mTransientLaunch 一般为默认值 false
47.                 mRootWindowContainer.resumeFocusedTasksTopActivities(
48.                         mTargetRootTask, mStartActivity, mOptions, mTransientLaunch);
49.             }
50.             ......
51.         }

复制代码

• 
  
  • 创建 Task
    
     
  
  
  
  • 我们知道 ActivityRecord 必要挂载到一个 Task 下，虽然这里调用的方法名是 getOrCreateRootTask（获取大概创建Task），但是当前场景肯定是创建一个，热启动是获取。
    
  • 另外 Task 创建的时间就会挂载到层级树中，也就是会挂载到DefaultTaskDisplayArea 下
    
  
  
• 
  
  • 将 ActivityRecord 挂载到创建的 Task 下
    
     
  
  
  
  • 上一末节没做的事，在这里就完成了挂载
    
  
  
• 
  
  • 移动 Task 到栈顶
    
     
  
  
  
  • 因为这个新启动的 Activity 必要表现，以是必要将它所在的 Task 移到容器顶部。 不过当前场景建好就已经是栈顶了，其实这一步没做什么，这点后面代码会分析
    
  
  
• 
  
  • 表现顶部的 Activity
    
     
  
  
  
  • 窗口层级的处置惩罚好了，就可以处置惩罚表现逻辑了，这里后续的逻辑会触发 Activity 的启动
    
  
  

3.4.1 获取Task–getOrCreateRootTask

调用链

1. ActivityStarter::getOrCreateRootTask
2.     RootWindowContainer::getOrCreateRootTask
3.         RootWindowContainer::getOrCreateRootTask
4.             TaskDisplayArea::getOrCreateRootTask
5.                 TaskDisplayArea::getOrCreateRootTask
6.                     Task::Build     ---创建Task

复制代码

开始看代码：

1. # ActivityStarter
2.     private Task getOrCreateRootTask(ActivityRecord r, int launchFlags, Task task,
3.             ActivityOptions aOptions) {
4.         final boolean onTop =
5.                 (aOptions == null || !aOptions.getAvoidMoveToFront()) && !mLaunchTaskBehind;
6.         final Task sourceTask = mSourceRecord != null ? mSourceRecord.getTask() : null;
7.         return mRootWindowContainer.getOrCreateRootTask(r, aOptions, task, sourceTask, onTop,
8.                 mLaunchParams, launchFlags);
9.     }

复制代码

• 
  
  • onTop 体现是否要移到到当前栈顶，那肯定是要的，新启动的 Activity 当前要在最上面，这里 aOptions.getAvoidMoveToFront 和 mLaunchTaskBehind 都为false，以是 onTop 为 true
    
  
  
• 
  
  • sourceTask 体现从哪里启动的，当前 Launcher 所在的 Task 就是 sourceTask
    
  
  

然后开始获取一个 Task 如果没有就新建一个。

1. # RootWindowContainer
2.     Task getOrCreateRootTask(@Nullable ActivityRecord r, @Nullable ActivityOptions options,
3.             @Nullable Task candidateTask, boolean onTop) {
4.         return getOrCreateRootTask(r, options, candidateTask, null /* sourceTask */, onTop,
5.                 null /* launchParams */, 0 /* launchFlags */);
6.     }
7.     Task getOrCreateRootTask(@Nullable ActivityRecord r,
8.             @Nullable ActivityOptions options, @Nullable Task candidateTask,
9.             @Nullable Task sourceTask, boolean onTop,
10.             @Nullable LaunchParamsController.LaunchParams launchParams, int launchFlags) {
11.             ......
12.             final int activityType = resolveActivityType(r, options, candidateTask);
13.             if (taskDisplayArea != null) {
14.                 if (canLaunchOnDisplay(r, taskDisplayArea.getDisplayId())) {
15.                     // 重点*1. 传递到TaskDisplayArea
16.                     return taskDisplayArea.getOrCreateRootTask(r, options, candidateTask,
17.                             sourceTask, launchParams, launchFlags, activityType, onTop);
18.                 } else {
19.                     taskDisplayArea = null;
20.                 }
21.             }
22.             ......
23.     }

复制代码

经过同名方法调用后，逻辑进入到 TaskDisplayArea::getOrCreateRootTask 。

1. # TaskDisplayArea
2.     Task getOrCreateRootTask(int windowingMode, int activityType, boolean onTop,
3.             @Nullable Task candidateTask, @Nullable Task sourceTask,
4.             @Nullable ActivityOptions options, int launchFlags) {
5.             if(....) {
6.                 // 拿到之前创建的Task
7.                 return candidateTask.getRootTask();
8.             }
9.             ......// 第一次显示所以是新建Task
10.             return new Task.Builder(mAtmService)
11.                 .setWindowingMode(windowingMode)
12.                 .setActivityType(activityType)
13.                 .setOnTop(onTop)
14.                 .setParent(this)  // 主要这个this被设置为Parent。所以直接挂载到了DefaultTaskDisplayArea下
15.                 .setSourceTask(sourceTask)
16.                 .setActivityOptions(options)
17.                 .setLaunchFlags(launchFlags)
18.                 .build();
19.     }

复制代码

看方法名是获取或创建 Task ，当前流程是新启动的 Activity 以是必要创建 Task 。如果是以默认启动方式打开应用内的另一个 Activity ，就走的是上面的 “return candidateTask.getRootTask();”
   设置的 parent 就是层级结构树应用所在的名为“DefaultTaskDisplayArea”的 TaskDisplayArea
  接下来就是真正触发Task的创建。

1. # Task
2.     # Task.Builder
3.         Task build() {
4.             if (mParent != null && mParent instanceof TaskDisplayArea) {
5.                 validateRootTask((TaskDisplayArea) mParent);
6.             }
8.             ......
9.             // 重点* 1. 创建task
10.             final Task task = buildInner();
11.             task.mHasBeenVisible = mHasBeenVisible;
13.             // Set activity type before adding the root task to TaskDisplayArea, so home task can
14.             // be cached, see TaskDisplayArea#addRootTaskReferenceIfNeeded().
15.             if (mActivityType != ACTIVITY_TYPE_UNDEFINED) {
16.                 task.setActivityType(mActivityType);
17.             }
18.             // 重点* 2. 入栈 这里的 mOnTop 为true
19.             if (mParent != null) {
20.                 if (mParent instanceof Task) {
21.                     final Task parentTask = (Task) mParent;
22.                     parentTask.addChild(task, mOnTop ? POSITION_TOP : POSITION_BOTTOM,
23.                             (mActivityInfo.flags & FLAG_SHOW_FOR_ALL_USERS) != 0);
24.                 } else {
25.                     mParent.addChild(task, mOnTop ? POSITION_TOP : POSITION_BOTTOM);
26.                 }
27.             }
29.             // Set windowing mode after attached to display area or it abort silently.
30.             if (mWindowingMode != WINDOWING_MODE_UNDEFINED) {
31.                 task.setWindowingMode(mWindowingMode, true /* creating */);
32.             }
33.             // 返回
34.             return task;
35.         }
37.         // 创建
38.         Task buildInner() {
39.             return new Task(mAtmService, mTaskId, mIntent, mAffinityIntent, mAffinity,
40.                     mRootAffinity, mRealActivity, mOrigActivity, mRootWasReset, mAutoRemoveRecents,
41.                     mAskedCompatMode, mUserId, mEffectiveUid, mLastDescription, mLastTimeMoved,
42.                     mNeverRelinquishIdentity, mLastTaskDescription, mLastSnapshotData,
43.                     mTaskAffiliation, mPrevAffiliateTaskId, mNextAffiliateTaskId, mCallingUid,
44.                     mCallingPackage, mCallingFeatureId, mResizeMode, mSupportsPictureInPicture,
45.                     mRealActivitySuspended, mUserSetupComplete, mMinWidth, mMinHeight,
46.                     mActivityInfo, mVoiceSession, mVoiceInteractor, mCreatedByOrganizer,
47.                     mLaunchCookie, mDeferTaskAppear, mRemoveWithTaskOrganizer);
48.         }

复制代码

3.4.1.1 小结

最后描述一下最后创建的2个重点部分：

• 
  
  • 看到通过 buildInner 创建了一个 Task，而 buildInner 也很简朴粗暴，通过各个变量直接 new 出一个 Task 对象。
    
  
  
• 
  
  • mParent 不为 null ，是因为在创建的时间 setParent（this）,当前的这个 this 就是 getDefaultTaskDisplayArea 返回的。就是 37层的第二层应用 Activity 存在的"DefaultTaskDisplayArea"
    
  
  

在 RootWindowContainer::getOrCreateRootTask 体现。

注意 log 里的 #17 的这个 Task 与前面的层级结构树新增的 Task 是对应的上的。而且"this= DefaultTaskDisplayArea "阐明也确实是往 DefaultTaskDisplayArea 里添加了。
另外 log 里 index 为3，结合最上面的前后对比，阐明也的往顶部添加。
3.4.2 ActivityRecord挂载到Task–setNewTask

调用链

1.     ActivityStarter::setNewTask
2.         ActivityStarer::addOrReparentStartingActivity

复制代码

主流程代码

1. # ActivityStarer
3.     private void setNewTask(Task taskToAffiliate) {
4.         // 为true
5.         final boolean toTop = !mLaunchTaskBehind && !mAvoidMoveToFront;
6.         // 就是mTargetRootTask,也就是刚刚创建的Task
7.         final Task task = mTargetRootTask.reuseOrCreateTask(
8.                 mNewTaskInfo != null ? mNewTaskInfo : mStartActivity.info,
9.                 mNewTaskIntent != null ? mNewTaskIntent : mIntent, mVoiceSession,
10.                 mVoiceInteractor, toTop, mStartActivity, mSourceRecord, mOptions);
11.         task.mTransitionController.collectExistenceChange(task);
12.         // ActivityRecord的挂载
13.         addOrReparentStartingActivity(task, "setTaskFromReuseOrCreateNewTask");
14.         // 需要注意这里的日志打印
15.         ProtoLog.v(WM_DEBUG_TASKS, "Starting new activity %s in new task %s",
16.                 mStartActivity, mStartActivity.getTask());
18.         // mLaunchTaskBehind 为false，所以taskToAffiliate 为null
19.         if (taskToAffiliate != null) {
20.             mStartActivity.setTaskToAffiliateWith(taskToAffiliate);
21.         }
22.     }

复制代码

这里的 Task 和 mTargetRootTask 是同一个对象，然后进入 ActivityStarer::addOrReparentStartingActivity 。

1. # ActivityStarer
3.     private void addOrReparentStartingActivity(@NonNull Task task, String reason) {
4.         //  newParent = task 都是刚刚创建的Task
5.         TaskFragment newParent = task;
6.         ......
7.         if (mStartActivity.getTaskFragment() == null
8.                 || mStartActivity.getTaskFragment() == newParent) {
9.             // 重点， 将 ActivityRecord挂在到新创建的Task中，并且是顶部
10.             newParent.addChild(mStartActivity, POSITION_TOP);
11.         } else {
12.             mStartActivity.reparent(newParent, newParent.getChildCount() /* top */, reason);
13.         }
14.     }

复制代码

这里的逻辑涉及到的 Task 就是上一步创建的 Task ，而 mStartActivity 则是“电话”在之前逻辑创建的 ActivityRecord 。
setNewTask的堆栈信息如下

另外这段逻辑里有个 ProtoLog 打印，日记如下：

3.4.2.1 小结

结合逻辑分析 + 堆栈信息 + ProtoLog ，可以确认 ActivityStarer::setNewTask 做的事情就是将 ActivityRecord 挂在到 Task 中，而且在顶部。
3.4.3 移动Task到容器顶部–moveToFront

这里提一下这个 moveToFront 方法，因为前面创建 Task 并添加到 DefaultTaskDisplayArea 时是往顶部添加，后面将 ActivityRecord 挂在到 Task 也是挂在到其顶部。以是这个函数其实没有什么现实操作。但是对于其他场景，这里也是一个重点方法。
调用链

1. Task::moveToFront
2.     Task::moveToFrontInner
3.         TaskDisplayArea::positionChildAt
4.             TaskDisplayArea::positionChildTaskAt
5.                 ActivityTaskSupervisor::updateTopResumedActivityIfNeeded
6.                     ActivityRecord::onTopResumedActivityChanged      --触发TopResumedActivityChangeItem

复制代码

主流程代码
首先确定一个问题：必要移动到顶部的是哪个 Task ？ 这个 Task 所在的是在哪个哪个容器？
在 ActivityStarter::startActivityInner 的时间调用的是这段代码：

1. // targetTask 当前场景为null
2. mTargetRootTask.getRootTask().moveToFront("reuseOrNewTask", targetTask);

复制代码

已知 mTargetRootTask 是新创建给“电话”用的 Task, 而 mTargetRootTask.getRootTask() 返回值当前场景是 mTargetRootTask 本身。

1. # Task
3.     void moveToFront(String reason, Task task) {
4.         if (!isAttached()) {
5.             return;
6.         }
7.         mTransitionController.recordTaskOrder(this);
9.         final TaskDisplayArea taskDisplayArea = getDisplayArea();
11.         if (!isActivityTypeHome() && returnsToHomeRootTask()) {
12.             // Make sure the root home task is behind this root task since that is where we
13.             // should return to when this root task is no longer visible.
14.             taskDisplayArea.moveHomeRootTaskToFront(reason + " returnToHome");
15.         }
17.         final Task lastFocusedTask = isRootTask() ? taskDisplayArea.getFocusedRootTask() : null;
18.         if (task == null) {
19.             // 当前场景为null，所以会赋值成新建的 Task ，也就是 mTargetRootTask 也就是电话的 Task
20.             task = this;
21.         }
22.         // 这里调用 getParent 就是 DefaultTaskDisplayArea 了。
23.         // 把当前的 Task 移动到 DefaultTaskDisplayArea 的最前面
24.         task.getParent().positionChildAt(POSITION_TOP, task, true /* includingParents */);
25.         taskDisplayArea.updateLastFocusedRootTask(lastFocusedTask, reason);
26.     }

复制代码

再回答一下问题：移动的是新建的电话 Task ，它的父容器是 DefaultTaskDisplayArea ，以是是把这个 Task 移动到 DefaultTaskDisplayArea 的最前面。
   mTargetRootTask.getRootTask 返回的是顶部的 Task, 当前 Task 上一层是 TaskDisplayArea 类型 （name为DefaultTaskDisplayArea）
  而 mTargetRootTask.getParent 返回的父容器(不限制是 Task)，则是 name 为 DefaultTaskDisplayArea 的 TaskDisplayArea。
  getRootTask 和 getParent 的区别可以自行去源码中看看
  到这里，AMS已经将必要的 ActivityRecord 和 Task 创建并且挂载到层级树中，接下来将是必要处置惩罚 TargetActivity 启动和表现逻辑了
3.4.4 表现Activity–resumeFocusedTasksTopActivities

首先看方法格局标必要表现一个栈顶的 Activity ，那说的不就是 TargetActivity 嘛，TargetActivity 的 ActivityRecord 已经创建并且移动到栈顶了。
前面该做的也都做好了，如今也确实是时间处置惩罚表现逻辑，这部分流程由 RootWindowContainer::resumeFocusedTasksTopActivities 实行，调用链如下：

1. RootWindowContainer::resumeFocusedTasksTopActivities
2.     Task::resumeTopActivityUncheckedLocked
3.         Task::resumeTopActivityInnerLocked
4.             TaskFragment::resumeTopActivity
5.                 TaskDisplayArea::pauseBackTasks  --   pause LauncherActivity
6.                     WindowContainer::forAllLeafTask
7.                         TaskFragment::forAllLeafTaskFragments
8.                             TaskFragment::startPausing
9.                                 TaskFragment::startPausing
10.                                     TaskFragment::schedulePauseActivity --构建 PauseActivityItem，这里是触发暂停launch
11.                 ActivityTaskManagerService::startProcessAsync     -- 创建“电话”进程

复制代码

重点方法在 TaskFragment::resumeTopActivity 开始处置惩罚，先简朴看一下前面的调用是怎么样的。

1. # RootWindowContainer
2.     // 第四个参数为 false
3.     boolean resumeFocusedTasksTopActivities(
4.             Task targetRootTask, ActivityRecord target, ActivityOptions targetOptions,
5.             boolean deferPause) {
6.                 ......
7.                 if (targetRootTask != null && (targetRootTask.isTopRootTaskInDisplayArea()
8.                         || getTopDisplayFocusedRootTask() == targetRootTask)) {
9.                     
10.                     result = targetRootTask.resumeTopActivityUncheckedLocked(target, targetOptions,
11.                             deferPause);
12.                 }
13.                 ......
14.             }
15. # Task
16.     boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options,
17.             boolean deferPause) {
18.                 ......
19.                 if (isLeafTask()) {
20.                     if (isFocusableAndVisible()) {
21.                         someActivityResumed = resumeTopActivityInnerLocked(prev, options, deferPause);
22.                     }
23.                 }
24.                 ......
25.             }
27.     private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options,
28.             boolean deferPause) {
29.                 ......
30.                 // deferPause = false
31.                 resumed[0] = topFragment.resumeTopActivity(prev, options, deferPause);
32.                 ......
33.             }

复制代码

由于篇幅原因，下面的 TaskFragment::resumeTopActivity 流程放在下一篇。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。