「安卓framework基础篇8」从WMS到BufferQueue第二篇 - Activity的生命周期：Task与ActivityRecord节点的创建及挂载(基于AOSP13)
上一篇文章：「安卓framework基础篇7」从WMS到BufferQueue第一篇 - WMS层级树的初始化过程(基于AOSP13)，我们分析了WMS的层级树是如何构建的，对WMS的层级树数据结构也有了一定的了解，本篇咱们以开机后第一次打开系统桌面的过程为例子，分析一个Activity是如何被挂载到WMS层级树上的。
警告：本篇介绍的代码逻辑分支较多，涉及到的成员变量较多，需要跟踪代码死磕，不然无法理解。实在无法理解的地方建议使用claude code + 大模型 来分析。
SystemServer.java的startOtherServices方法创建完wms、ams后，会调用ams的systemReady方法：
private void startOtherServices(@NonNullTimingsTraceAndSlog t) { // 省略 // 创建wms wm = WindowManagerService.main(context, inputManager, !mFirstBoot, mOnlyCore, new PhoneWindowManager(), mActivityManagerService.mActivityTaskManager); // 省略 // 将wms传递给ams mActivityManagerService.setWindowManager(wm); // 省略 // 执行启动准备方法 mActivityManagerService.systemReady(() -> { // 省略 }, t); // 省略 }
将wms传递给ams时会为系统桌面app创建一个专属的RootTask节点，为后续挂载ActivityRecrod节点做准备：
void setWindowManager(WindowManagerService wm) { // 省略 // 获取默认的TDA节点(专门挂载app任务的节点) final TaskDisplayArea defaultTaskDisplayArea = getDefaultTaskDisplayArea(); // 这里会创建一个ActivityType为ACTIVITY_TYPE_HOME的Task节点，挂载到DefaultTaskDisplayArea节点上 // 这个Task节点是专门挂载系统应用Task的父节点，作为系统级应用task位置在WMS层级树中的锚定。 defaultTaskDisplayArea.getOrCreateRootHomeTask(ON_TOP); // 省略 }
之后执行ActivityManagerService.java的systemReady方法开始启动系统桌面：
public void systemReady(final Runnable goingCallback, @NonNullTimingsTraceAndSlog t) { // 省略 if (bootingSystemUser) { t.traceBegin("startHomeOnAllDisplays"); // 开始启动系统桌面 mAtmInternal.startHomeOnAllDisplays(currentUserId, "systemReady"); t.traceEnd(); }// 省略 }
RootWindowContainer.java 的 startHomeOnDisplay方法：
boolean startHomeOnDisplay(int userId, String reason, int displayId, boolean allowInstrumenting, boolean fromHomeKey) { // 省略 return display.reduceOnAllTaskDisplayAreas((taskDisplayArea, result) -> // 开始在TDA中启动系统桌面 result | startHomeOnTaskDisplayArea(userId, reason, taskDisplayArea, allowInstrumenting, fromHomeKey), false /* initValue */); }
RootWindowContainer.java 的 startHomeOnTaskDisplayArea方法：
boolean startHomeOnTaskDisplayArea(int userId, String reason, TaskDisplayArea taskDisplayArea, boolean allowInstrumenting, boolean fromHomeKey) { // 省略 // 调用atms启动系统桌面Activity mService.getActivityStartController().startHomeActivity(homeIntent, aInfo, myReason, taskDisplayArea); // 省略 }
ActivityStartController.java 的 startHomeActivity 方法：
void startHomeActivity(Intent intent, ActivityInfo aInfo, String reason, TaskDisplayArea taskDisplayArea) { // 省略 mLastHomeActivityStartResult = obtainStarter(intent, "startHomeActivity: " + reason) .setOutActivity(tmpOutRecord) .setCallingUid(0) .setActivityInfo(aInfo) .setActivityOptions(options.toBundle()) // 开始启动系统桌面 .execute(); // 省略 }
ActivityStarter.java 的 execute 方法**（从这里开始，与启动普通app创建Activity共用一套代码）**：
intexecute() { // 省略 res = executeRequest(mRequest); // 省略 }
ActivityStarter.java 的 executeRequest 方法：
private int executeRequest(Request request) { // 省略 // 创建当前应用的ActivityRecord对象，也就是系统桌面的ActivityRecord。 final ActivityRecord r = new ActivityRecord.Builder(mService) .setCaller(callerApp) .setLaunchedFromPid(callingPid) .setLaunchedFromUid(callingUid) .setLaunchedFromPackage(callingPackage) .setLaunchedFromFeature(callingFeatureId) .setIntent(intent) .setResolvedType(resolvedType) .setActivityInfo(aInfo) .setConfiguration(mService.getGlobalConfiguration()) .setResultTo(resultRecord) .setResultWho(resultWho) .setRequestCode(requestCode) .setComponentSpecified(request.componentSpecified) .setRootVoiceInteraction(voiceSession != null) .setActivityOptions(checkedOptions) .setSourceRecord(sourceRecord) .build(); // 省略 // 开始启动Activity mLastStartActivityResult = startActivityUnchecked(r, sourceRecord, voiceSession, request.voiceInteractor, startFlags, true /* doResume */, checkedOptions, inTask, inTaskFragment, restrictedBgActivity, intentGrants); // 省略 }
ActivityStarter.java 的 startActivityUnchecked 方法：
private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord, IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor, int startFlags, boolean doResume, ActivityOptions options, Task inTask, TaskFragment inTaskFragment, boolean restrictedBgActivity, NeededUriGrants intentGrants) { // 省略 // 开始执行启动Activity的核心方法 result = startActivityInner(r, sourceRecord, voiceSession, voiceInteractor, startFlags, doResume, options, inTask, inTaskFragment, restrictedBgActivity, intentGrants); // 省略 }
ActivityStarter.java 的 startActivityInner 方法**（开始启动Activity的核心方法）**：
@VisibleForTesting int startActivityInner(final ActivityRecord r, ActivityRecord sourceRecord, IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor, int startFlags, boolean doResume, ActivityOptions options, Task inTask, TaskFragment inTaskFragment, boolean restrictedBgActivity, NeededUriGrants intentGrants) { // 省略 if (mTargetRootTask == null) { // 找到已有RootTask复用，找不到就新建一个RootTask mTargetRootTask = getOrCreateRootTask(mStartActivity, mLaunchFlags, targetTask, mOptions); } if (newTask) { final Task taskToAffiliate = (mLaunchTaskBehind && mSourceRecord != null) ? mSourceRecord.getTask() : null; // 将ActivityRecord挂载到RootTask下 setNewTask(taskToAffiliate); } else if (mAddingToTask) { addOrReparentStartingActivity(targetTask, "adding to task"); } // 省略 // 如果是第一次打开app，则为Activity创建对应的app进程 mTargetRootTask.startActivityLocked(mStartActivity, topRootTask, newTask, isTaskSwitch, mOptions, sourceRecord); if (mDoResume) { final ActivityRecord topTaskActivity = startedTask.topRunningActivityLocked(); if (!mTargetRootTask.isTopActivityFocusable() || (topTaskActivity != null && topTaskActivity.isTaskOverlay() && mStartActivity != topTaskActivity)) { // 省略 } else { // 省略 if (mTargetRootTask.isTopActivityFocusable() && !mRootWindowContainer.isTopDisplayFocusedRootTask(mTargetRootTask)) { // 把 mTargetRootTask放到DisplayArea的子节点的最后一个，代表最顶层task // 并让 focused root task 指针指向它 mTargetRootTask.moveToFront("startActivityInner"); } // 重新计算所有Task下的所有Activity的可见性 // 然后通知可见的Activity的onResume生命周期回调 mRootWindowContainer.resumeFocusedTasksTopActivities( mTargetRootTask, mStartActivity, mOptions, mTransientLaunch); } } // 省略 }
上面这个方法比较复杂，做的事较多，主要做了这么几件事：
如果当前是为已经打开了的APP启动新的Activity，则找到已存在的RootTask，否则就新建一个RootTask (getOrCreateRootTask)
将当前要打开的ActivityRecord挂载到RootTask下 (setNewTask)
如果是第一次打开app，则要调用Zygote为Activity创建对应的app进程 (startActivityLocked)
把 mTargetRootTask置顶并让 focused root task 指针指向它 (moveToFront)
重新计算所有Task下的所有Activity的可见性 (resumeFocusedTasksTopActivities)
通知可见的Activity的onResume生命周期回调 (resumeFocusedTasksTopActivities)
我们重点关注的比较重要的事为：
- 将当前要打开的ActivityRecord挂载到RootTask下
- 如果是第一次打开app，则要调用Zygote为Activity创建对应的app进程
- 重新计算所有Task下的所有Activity的可见性
- 通知可见的Activity的onResume生命周期回调
本篇先分析这两件事：
- 将当前要打开的ActivityRecord挂载到RootTask下
- 重新计算所有Task下的所有Activity的可见性
剩下的事我们放到后面的文章中来说。
1. 将当前要打开的ActivityRecord挂载到RootTask下
ActivityStarter.java 的 setNewTask 方法：
private void setNewTask(Task taskToAffiliate) { //省略 addOrReparentStartingActivity(task, "setTaskFromReuseOrCreateNewTask");//省略 }
ActivityStarter.java 的 addOrReparentStartingActivity 方法：
private void addOrReparentStartingActivity(@NonNullTask task, String reason) { //省略 if (mStartActivity.getTaskFragment() == null || mStartActivity.getTaskFragment() == newParent) { // 将当前的ActivityRecord挂载到新Task下 newParent.addChild(mStartActivity, POSITION_TOP); } //省略 }
2. 重新计算所有Task下的所有Activity的可见性
RootWindowContainer.java的 resumeFocusedTasksTopActivities 方法：
boolean resumeFocusedTasksTopActivities( Task targetRootTask, ActivityRecord target, ActivityOptions targetOptions, boolean deferPause) { //省略 // 判端当前RootTask是不是在DisplayArea的最顶层，之前已经将task放到最顶层了，所以是的 if (targetRootTask != null && (targetRootTask.isTopRootTaskInDisplayArea() || getTopDisplayFocusedRootTask() == targetRootTask)) { // 开始恢复（resume）焦点任务的栈顶 Activity，让新启动的 Activity 进入前台可交互状态。 result = targetRootTask.resumeTopActivityUncheckedLocked(target, targetOptions, deferPause); } //省略 }
Task.java 的 resumeTopActivityUncheckedLocked 方法：
@GuardedBy("mService") boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options, boolean deferPause) { // 省略 try { // Protect against recursion. mInResumeTopActivity = true; // 如果当前是leafTask则开始执行resumeTopActivityInnerLocked if (isLeafTask()) { if (isFocusableAndVisible()) { someActivityResumed = resumeTopActivityInnerLocked(prev, options, deferPause); } } else { // 否在在这里遍历自己的子Task，用子Task对象递归调用本方法，直到找到leafTask int idx = mChildren.size() - 1; while (idx >= 0) { final Task child = (Task) getChildAt(idx--); if (!child.isTopActivityFocusable()) { continue; } if (child.getVisibility(null /* starting */) != TASK_FRAGMENT_VISIBILITY_VISIBLE) { break; } someActivityResumed |= child.resumeTopActivityUncheckedLocked(prev, options, deferPause); // 省略 if (idx >= mChildren.size()) { idx = mChildren.size() - 1; } } } // 省略 } // 省略 }
Task.java的 resumeTopActivityInnerLocked 方法：
@GuardedBy("mService") private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options, boolean deferPause) { // 省略 // 找到当前leafTask下最顶层的Activity final ActivityRecord topActivity = topRunningActivity(true /* focusableOnly */); // 省略 final boolean[] resumed = new boolean[1]; // 获取当前leafTask下最顶层的Activity的TaskFragment，也就是当前这个task final TaskFragment topFragment = topActivity.getTaskFragment(); // 执行顶层task的resumeTopActivity方法 resumed[0] = topFragment.resumeTopActivity(prev, options, deferPause); // 如果leafTask下还有TaskFragment，则遍历执行每个TaskFragment的resumeTopActivity方法 forAllLeafTaskFragments(f -> { if (topFragment == f) { return; } if (!f.canBeResumed(null /* starting */)) { return; } resumed[0] |= f.resumeTopActivity(prev, options, deferPause); }, true); return resumed[0]; }
TaskFragment.java 的 resumeTopActivity 方法：
final boolean resumeTopActivity(ActivityRecord prev, ActivityOptions options, boolean deferPause) { // 省略 final TaskDisplayArea taskDisplayArea = getDisplayArea(); // 省略 if (mResumedActivity == next && next.isState(RESUMED) && taskDisplayArea.allResumedActivitiesComplete()) { // 调用当前所在TaskDisplayArea的ensureActivitiesVisible方法，计算所有Activity的可见性 taskDisplayArea.ensureActivitiesVisible(null /* starting */, 0 /* configChanges */, false /* preserveWindows */, true /* notifyClients */); // 省略 } // 省略 }
TaskDisplayArea.java 的 ensureActivitiesVisible 方法：
这个方法在很多地方都有用到，但凡对层级树做结构的修改，都要调用一下这个方法重新计算层级树中所有Activity的可见性
void ensureActivitiesVisible(ActivityRecord starting, int configChanges, boolean preserveWindows, boolean notifyClients) { mAtmService.mTaskSupervisor.beginActivityVisibilityUpdate(); try { // 遍历当前TaskDisplayArea下所有的RootTask节点，执行它们的ensureActivitiesVisible方法 forAllRootTasks(rootTask -> { rootTask.ensureActivitiesVisible(starting, configChanges, preserveWindows, notifyClients); }); } finally { mAtmService.mTaskSupervisor.endActivityVisibilityUpdate(); } }
Task.java 的 ensureActivitiesVisible 方法：
void ensureActivitiesVisible(@NullableActivityRecord starting, int configChanges, boolean preserveWindows, boolean notifyClients) { // 省略 try { // 遍历当前RootTask下所有的leafTask节点，执行它们的 updateActivityVisibilities 方法 forAllLeafTasks(task -> { task.updateActivityVisibilities(starting, configChanges, preserveWindows, notifyClients); }, true /* traverseTopToBottom */); // 省略 } // 省略 }
TaskFragment.java 的 updateActivityVisibilities 方法：
final void updateActivityVisibilities(@Nullable ActivityRecord starting, int configChanges, boolean preserveWindows, boolean notifyClients) { // 省略 // 最后调用leafTask中成员变量mEnsureActivitiesVisibleHelper的process方法 mEnsureActivitiesVisibleHelper.process( starting, configChanges, preserveWindows, notifyClients); // 省略 }
EnsureActivitiesVisibleHelper.java 的 process 方法：
void process(@Nullable ActivityRecord starting, int configChanges, boolean preserveWindows, boolean notifyClients) { // 省略 // 开始遍历当前leafTask节点下所有的ActivityRecord，计算其可见性 for (int i = mTaskFragment.mChildren.size() - 1; i >= 0; --i) { // 省略 if (childTaskFragment != null && childTaskFragment.getTopNonFinishingActivity() != null) { // 省略 } else if (child.asActivityRecord() != null) { // 设置当前ActivityRecord的可见性 setActivityVisibilityState(child.asActivityRecord(), starting, resumeTopActivity); } } }
EnsureActivitiesVisibleHelper.java 的 setActivityVisibilityState 方法：
private void setActivityVisibilityState(ActivityRecord r, ActivityRecord starting, final boolean resumeTopActivity) { // 省略 if (r.visibleIgnoringKeyguard) { if (r.occludesParent()) { // 省略 // 如果当前Activity是不透明的则将mBehindFullyOccludedContainer设置为true mBehindFullyOccludedContainer = true; } else { mBehindFullyOccludedContainer = false; } } // 省略 // 如果当前Activity是可见的 if (reallyVisible) { // finishing代表当前的Activity已经销毁 if (r.finishing) { return; } // 省略 // 如果当前Activity没有对应的进程，则开始为其创建进程 if (!r.attachedToProcess()) { // 将当前的Activity设置为可见也在这里面处理 makeVisibleAndRestartIfNeeded(mStarting, mConfigChanges, isTop, resumeTopActivity && isTop, r); } // 省略 } else { if (DEBUG_VISIBILITY) { Slog.v(TAG_VISIBILITY, "Make invisible? " + r + " finishing=" + r.finishing + " state=" + r.getState() + " containerShouldBeVisible=" + mContainerShouldBeVisible + " behindFullyOccludedContainer=" + mBehindFullyOccludedContainer + " mLaunchTaskBehind=" + r.mLaunchTaskBehind); } // 设置当前的Activity为不可见 r.makeInvisible(); } // 省略 }
EnsureActivitiesVisibleHelper.java 的 makeVisibleAndRestartIfNeeded 方法：
private void makeVisibleAndRestartIfNeeded(ActivityRecord starting, int configChanges, boolean isTop, boolean andResume, ActivityRecord r) { // 省略 if (!r.mVisibleRequested || r.mLaunchTaskBehind) { if (DEBUG_VISIBILITY) { Slog.v(TAG_VISIBILITY, "Starting and making visible: " + r); } // 将当前Activity状态设置为可见，并触发Activity生命周期中的onResume方法 r.setVisibility(true); } if (r != starting) { // 开始启动进程 mTaskFragment.mTaskSupervisor.startSpecificActivity(r, andResume, true /* checkConfig */); } }
以上就是Activity挂载到WMS层级树上的整个过程，代码比较绕但并没有很复杂的算法，与java后端开发平时写的屎山代码差不多，要理解透彻的话还需要死磕。
最后以一张图结束本篇
Task和ActivityRecord的关系
10个月宝宝每天需要喝多少奶粉？