上篇梳理到：
TaskDisplayArea和Task的复用与创建
TaskDisplayArea
executeRequest后，随后调用startActivityUnchecked，进而调用startActivityInner。
platform/frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java
private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord, IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor, int startFlags, ActivityOptions options, Task inTask, TaskFragment inTaskFragment, @BalCode int balCode, NeededUriGrants intentGrants, int realCallingUid) {
...
result = startActivityInner(r, sourceRecord, voiceSession, voiceInteractor, startFlags, options, inTask, inTaskFragment, balCode, intentGrants, realCallingUid);
}
int startActivityInner(final ActivityRecord r, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
int startFlags, ActivityOptions options, Task inTask,
TaskFragment inTaskFragment, @BalCode int balCode,
NeededUriGrants intentGrants, int realCallingUid) {
// 位置1：初始化启动参数
setInitialState(r, options, inTask, inTaskFragment, startFlags, sourceRecord,
voiceSession, voiceInteractor, balCode, realCallingUid);
computeLaunchingTaskFlags();
mIntent.setFlags(mLaunchFlags);
...
// 位置2：mPreferredTaskDisplayArea为RootWindowContainer.getDefaultTaskDisplayArea()
final Task prevTopRootTask = mPreferredTaskDisplayArea.getFocusedRootTask();
final Task prevTopTask = prevTopRootTask != null ? prevTopRootTask.getTopLeafTask() : null;
final Task reusedTask = getReusableTask();
...
final Task targetTask = reusedTask != null ? reusedTask : computeTargetTask();
final boolean newTask = targetTask == null;
mTargetTask = targetTask;
// 位置3：计算WindowingMode
computeLaunchParams(r, sourceRecord, targetTask);
int startResult = isAllowedToStart(r, newTask, targetTask);
...
final ActivityRecord targetTaskTop = newTask
? null : targetTask.getTopNonFinishingActivity();
if (targetTaskTop != null) {
// Removes the existing singleInstance activity in another task (if any) while
// launching a singleInstance activity on sourceRecord's task.
if (LAUNCH_SINGLE_INSTANCE == mLaunchMode && mSourceRecord != null
&& targetTask == mSourceRecord.getTask()) {
final ActivityRecord activity = mRootWindowContainer.findActivity(mIntent,
mStartActivity.info, false);
if (activity != null && activity.getTask() != targetTask) {
activity.destroyIfPossible("Removes redundant singleInstance");
}
}
recordTransientLaunchIfNeeded(targetTaskTop);
// Recycle the target task for this launch.
startResult = recycleTask(targetTask, targetTaskTop, reusedTask, intentGrants);
if (startResult != START_SUCCESS) {
return startResult;
}
} else {
mAddingToTask = true;
}
if (mTargetRootTask == null) {
mTargetRootTask = getOrCreateRootTask(mStartActivity, mLaunchFlags, targetTask,
mOptions);
}
if (newTask) {
final Task taskToAffiliate = (mLaunchTaskBehind && mSourceRecord != null)
? mSourceRecord.getTask() : null;
setNewTask(taskToAffiliate);
} else if (mAddingToTask) {
addOrReparentStartingActivity(targetTask, "adding to task");
}
...
mTargetRootTask.startActivityLocked(mStartActivity, topRootTask, newTask, isTaskSwitch,
mOptions, sourceRecord);
// **** 位置4
if (mDoResume) {
final ActivityRecord topTaskActivity = startedTask.topRunningActivityLocked();
if (!mTargetRootTask.isTopActivityFocusable()
|| (topTaskActivity != null && topTaskActivity.isTaskOverlay()
&& mStartActivity != topTaskActivity)) {
// If the activity is not focusable, we can't resume it, but still would like to
// make sure it becomes visible as it starts (this will also trigger entry
// animation). An example of this are PIP activities.
// Also, we don't want to resume activities in a task that currently has an overlay
// as the starting activity just needs to be in the visible paused state until the
// over is removed.
// Passing {@code null} as the start parameter ensures all activities are made
// visible.
mTargetRootTask.ensureActivitiesVisible(null /* starting */,
0 /* configChanges */, !PRESERVE_WINDOWS);
// Go ahead and tell window manager to execute app transition for this activity
// since the app transition will not be triggered through the resume channel.
mTargetRootTask.mDisplayContent.executeAppTransition();
} else {
// If the target root-task was not previously focusable (previous top running
// activity on that root-task was not visible) then any prior calls to move the
// root-task to the will not update the focused root-task. If starting the new
// activity now allows the task root-task to be focusable, then ensure that we
// now update the focused root-task accordingly.
if (!mAvoidMoveToFront && mTargetRootTask.isTopActivityFocusable()
&& !mRootWindowContainer.isTopDisplayFocusedRootTask(mTargetRootTask)) {
mTargetRootTask.moveToFront("startActivityInner");
}
mRootWindowContainer.resumeFocusedTasksTopActivities(
mTargetRootTask, mStartActivity, mOptions, mTransientLaunch);
}
}
mRootWindowContainer.updateUserRootTask(mStartActivity.mUserId, mTargetRootTask);
// Update the recent tasks list immediately when the activity starts
mSupervisor.mRecentTasks.add(startedTask);
mSupervisor.handleNonResizableTaskIfNeeded(startedTask,
mPreferredWindowingMode, mPreferredTaskDisplayArea, mTargetRootTask);
// If Activity's launching into PiP, move the mStartActivity immediately to pinned mode.
// Note that mStartActivity and source should be in the same Task at this point.
if (mOptions != null && mOptions.isLaunchIntoPip()
&& sourceRecord != null && sourceRecord.getTask() == mStartActivity.getTask()
&& balCode != BAL_BLOCK) {
mRootWindowContainer.moveActivityToPinnedRootTask(mStartActivity,
sourceRecord, "launch-into-pip");
}
return START_SUCCESS;
}mPreferredTaskDisplayArea的赋值来自setInitialState，
platform/frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java
private void setInitialState(ActivityRecord r, ActivityOptions options, Task inTask,
TaskFragment inTaskFragment, int startFlags,
ActivityRecord sourceRecord, IVoiceInteractionSession voiceSession,
IVoiceInteractor voiceInteractor, @BalCode int balCode, int realCallingUid) {
mStartActivity = r;
mIntent = r.intent;
mOptions = options;
mCallingUid = r.launchedFromUid;
mRealCallingUid = realCallingUid;
mSourceRecord = sourceRecord;
mSourceRootTask = mSourceRecord != null ? mSourceRecord.getRootTask() : null;
mVoiceSession = voiceSession;
mVoiceInteractor = voiceInteractor;
mBalCode = balCode;
mLaunchParams.reset();
mSupervisor.getLaunchParamsController().calculate(inTask, r.info.windowLayout, r, sourceRecord, options, mRequest, PHASE_DISPLAY, mLaunchParams);
mPreferredTaskDisplayArea = mLaunchParams.hasPreferredTaskDisplayArea()
? mLaunchParams.mPreferredTaskDisplayArea
: mRootWindowContainer.getDefaultTaskDisplayArea();
mPreferredWindowingMode = mLaunchParams.mWindowingMode;
mLaunchMode = r.launchMode;
mLaunchFlags = adjustLaunchFlagsToDocumentMode(
r, LAUNCH_SINGLE_INSTANCE == mLaunchMode,
LAUNCH_SINGLE_TASK == mLaunchMode, mIntent.getFlags());首先注意mStartActivity = r;的赋值。mStartActivity就是新new的ActivityRecord后面会用到。
mSupervisor.getLaunchParamsController()来自ActivityTaskSupervisor的初始化，调用其calculate方法。注意，这里传入的PHASE_DISPLAY：
platform/frameworks/base/services/core/java/com/android/server/wm/ActivityTaskSupervisor.java
public void initialize() {
mLaunchParamsController = new LaunchParamsController(mService, mLaunchParamsPersister);
mLaunchParamsController.registerDefaultModifiers(this);
}
void registerDefaultModifiers(ActivityTaskSupervisor supervisor) {
// {@link TaskLaunchParamsModifier} handles window layout preferences.
registerModifier(new TaskLaunchParamsModifier(supervisor));
if (DesktopModeLaunchParamsModifier.isDesktopModeSupported()) {
// {@link DesktopModeLaunchParamsModifier} handles default task size changes
registerModifier(new DesktopModeLaunchParamsModifier());
}
}我们看到，new了一个LaunchParamsController后，注册了Modifiers为new TaskLaunchParamsModifier。
LaunchParamsController的calculate代码：
platform/frameworks/base/services/core/java/com/android/server/wm/LaunchParamsController.java
void calculate(Task task, WindowLayout layout, ActivityRecord activity, ActivityRecord source,
ActivityOptions options, @Nullable Request request, int phase, LaunchParams result) {
if (task != null || activity != null) {
mPersister.getLaunchParams(task, activity, result);
}
// We start at the last registered {@link LaunchParamsModifier} as this represents
// The modifier closest to the product level. Moving back through the list moves closer to
// the platform logic.
for (int i = mModifiers.size() - 1; i >= 0; --i) {
mTmpCurrent.set(result);
mTmpResult.reset();
final LaunchParamsModifier modifier = mModifiers.get(i);
switch(modifier.onCalculate(task, layout, activity, source, options, request, phase,
mTmpCurrent, mTmpResult)) {
case RESULT_SKIP:
// Do not apply any results when we are told to skip
continue;
case RESULT_DONE:
// Set result and return immediately.
result.set(mTmpResult);
return;
case RESULT_CONTINUE:
// Set result and continue
result.set(mTmpResult);
break;
}
}
if (activity != null && activity.requestedVrComponent != null) {
// Check if the Activity is a VR activity. If so, it should be launched in main display.
result.mPreferredTaskDisplayArea = mService.mRootWindowContainer
.getDefaultTaskDisplayArea();
} else if (mService.mVr2dDisplayId != INVALID_DISPLAY) {
// Get the virtual display ID from ActivityTaskManagerService. If that's set we
// should always use that.
result.mPreferredTaskDisplayArea = mService.mRootWindowContainer
.getDisplayContent(mService.mVr2dDisplayId).getDefaultTaskDisplayArea();
}
}mModifiers目前只有一个成员，就是TaskLaunchParamsModifier，这里调用其onCalculate:
@Override
public int onCalculate(@Nullable Task task, @Nullable ActivityInfo.WindowLayout layout,
@Nullable ActivityRecord activity, @Nullable ActivityRecord source,
@Nullable ActivityOptions options, @Nullable Request request, int phase,
LaunchParams currentParams, LaunchParams outParams) {
initLogBuilder(task, activity);
final int result = calculate(task, layout, activity, source, options, request, phase,
currentParams, outParams);
outputLog();
return result;
}
private int calculate(@Nullable Task task, @Nullable ActivityInfo.WindowLayout layout,
@Nullable ActivityRecord activity, @Nullable ActivityRecord source,
@Nullable ActivityOptions options, @Nullable Request request, int phase,
LaunchParams currentParams, LaunchParams outParams) {
final ActivityRecord root;
if (task != null) {
root = task.getRootActivity() == null ? activity : task.getRootActivity();
} else {
root = activity;
}
if (root == null) {
// There is a case that can lead us here. The caller is moving the top activity that is
// in a task that has multiple activities to PIP mode. For that the caller is creating a
// new task to host the activity so that we only move the top activity to PIP mode and
// keep other activities in the previous task. There is no point to apply the launch
// logic in this case.
return RESULT_SKIP;
}
// STEP 1: Determine the suggested display area to launch the activity/task.
final TaskDisplayArea suggestedDisplayArea = getPreferredLaunchTaskDisplayArea(task,
options, source, currentParams, activity, request);
outParams.mPreferredTaskDisplayArea = suggestedDisplayArea;
final DisplayContent display = suggestedDisplayArea.mDisplayContent;
if (DEBUG) {
appendLog("display-id=" + display.getDisplayId()
+ " task-display-area-windowing-mode=" + suggestedDisplayArea.getWindowingMode()
+ " suggested-display-area=" + suggestedDisplayArea);
}
if (phase == PHASE_DISPLAY) {
return RESULT_CONTINUE;
}
...
}由于我们一开始的场景是从Context启动一个Activity，source、option、inTask等参数都是空，currentParams（从ActivityStarter.setInitialState构建而来）的mPreferredTaskDisplayArea也是空，所以getPreferredLaunchTaskDisplayArea方法最终会从getFallbackDisplayAreaForActivity方法获取mPreferredTaskDisplayArea：
/**
* Calculates the default {@link TaskDisplayArea} for a task. We attempt to put the activity
* within the same display area if possible. The strategy is to find the display in the
* following order:
*
* <ol>
* <li>The display area of the top activity from the launching process will be used</li>
* <li>The display area of the top activity from the real launching process will be used
* </li>
* <li>Default display area from the associated root window container.</li>
* </ol>
* @param activityRecord the activity being started
* @param request optional {@link Request} made to start the activity record
* @return {@link TaskDisplayArea} to house the task
*/
private TaskDisplayArea getFallbackDisplayAreaForActivity(
@NonNull ActivityRecord activityRecord, @Nullable Request request) {
WindowProcessController controllerFromLaunchingRecord = mSupervisor.mService
.getProcessController(activityRecord.launchedFromPid,
activityRecord.launchedFromUid);
final TaskDisplayArea displayAreaForLaunchingRecord = controllerFromLaunchingRecord == null
? null : controllerFromLaunchingRecord.getTopActivityDisplayArea();
if (displayAreaForLaunchingRecord != null) {
return displayAreaForLaunchingRecord;
}
WindowProcessController controllerFromProcess = mSupervisor.mService.getProcessController(
activityRecord.getProcessName(), activityRecord.getUid());
final TaskDisplayArea displayAreaForRecord = controllerFromProcess == null ? null
: controllerFromProcess.getTopActivityDisplayArea();
if (displayAreaForRecord != null) {
return displayAreaForRecord;
}
WindowProcessController controllerFromRequest = request == null ? null : mSupervisor
.mService.getProcessController(request.realCallingPid, request.realCallingUid);
final TaskDisplayArea displayAreaFromSourceProcess = controllerFromRequest == null ? null
: controllerFromRequest.getTopActivityDisplayArea();
if (displayAreaFromSourceProcess != null) {
return displayAreaFromSourceProcess;
}
return mSupervisor.mRootWindowContainer.getDefaultTaskDisplayArea();
}首先会根据activityRecord.launchedFromPid，也就是CallingPid（在ActivityStarter.executeReauest()时设置），或activityRecord.getProcessName，或者realCallingPid，去获取其所在的TopActivity所属的DisplayArea。比如如果是从Laucnher启动的一个新的Activity，那么此时会使用Launcher顶部Activity所属的DisplayArea。如果以上都没有找到， 则使用mRootWindowContainer的默认DefaultTaskDisplayArea。通常这个DefaultTaskDisplayArea是对应一个屏幕的DisplayContent。
回到calculate(方法。现在我们得到了suggestedDisplayArea，赋值给outParams.mPreferredTaskDisplayArea。由于上面我们传入的phase是PHASE_DISPLAY，所以下面直接返回return RESULT_CONTINUE;
再继续返回LaunchParamsController的calculate(..)， RESULT_CONTINUE对应的逻辑是result.set(mTmpResult);，就是将刚才outParams的值设置到in-out型参数result，返回给上层。而后面的activity.requestedVrComponent 等判断逻辑，都是跟VR场景有关的，不探讨。
回到ActivityStarter的startActivityInner， 假如我们现在只有一个物理屏幕，那么final Task prevTopRootTask = mPreferredTaskDisplayArea.getFocusedRootTask();返回的是默认DisplayContent的getFocusedRootTask：
platform/frameworks/base/services/core/java/com/android/server/wm/DisplayContent.java
@Nullable
Task getFocusedRootTask() {
return getItemFromTaskDisplayAreas(TaskDisplayArea::getFocusedRootTask);
}platform/frameworks/base/services/core/java/com/android/server/wm/WindowContainer.java
/**
* Finds the first non {@code null} return value from calling the callback on all
* {@link TaskDisplayArea} at or below this container.
* @param callback Applies on each {@link TaskDisplayArea} found and stops the search if it
* returns non {@code null}.
* @param traverseTopToBottom If {@code true}, traverses the hierarchy from top-to-bottom in
* terms of z-order, else from bottom-to-top.
* @return the first returned object that is not {@code null}. Returns {@code null} if not
* found.
*/
@Nullable
<R> R getItemFromTaskDisplayAreas(Function<TaskDisplayArea, R> callback,
boolean traverseTopToBottom) {
int childCount = mChildren.size();
int i = traverseTopToBottom ? childCount - 1 : 0;
while (i >= 0 && i < childCount) {
R result = (R) mChildren.get(i)
.getItemFromTaskDisplayAreas(callback, traverseTopToBottom);
if (result != null) {
return result;
}
i += traverseTopToBottom ? -1 : 1;
}
return null;
}platform/frameworks/base/services/core/java/com/android/server/wm/DisplayArea.java
@Nullable
@Override
<R> R getItemFromTaskDisplayAreas(Function<TaskDisplayArea, R> callback,
boolean traverseTopToBottom) {
// Only DisplayArea of Type.ANY may contain TaskDisplayArea as children.
if (mType != DisplayArea.Type.ANY) {
return null;
}
int childCount = mChildren.size();
int i = traverseTopToBottom ? childCount - 1 : 0;
while (i >= 0 && i < childCount) {
T child = mChildren.get(i);
// Only traverse if the child is a DisplayArea.
if (child.asDisplayArea() != null) {
R result = (R) child.asDisplayArea()
.getItemFromTaskDisplayAreas(callback, traverseTopToBottom);
if (result != null) {
return result;
}
}
i += traverseTopToBottom ? -1 : 1;
}
return null;
}platform/frameworks/base/services/core/java/com/android/server/wm/TaskDisplayArea.java
@Nullable
@Override
<R> R getItemFromTaskDisplayAreas(Function<TaskDisplayArea, R> callback,
boolean traverseTopToBottom) {
if (traverseTopToBottom) {
final R item = super.getItemFromTaskDisplayAreas(callback, traverseTopToBottom);
return item != null ? item : callback.apply(this);
} else {
final R item = callback.apply(this);
return item != null
? item
: super.getItemFromTaskDisplayAreas(callback, traverseTopToBottom);
}
}getItemFromTaskDisplayAreas是一个递归查询某TaskDisplayArea的首个非空child的方法。其参数callback是一个Function类型的参数，用于将TaskDisplayArea转换为R类型。
首先，getItemFromTaskDisplayAreas是在WindowContainer声明的，DisplayArea、TaskDisplayArea重载了getItemFromTaskDisplayAreas。所有的窗口类型（WindowToken、DisplayContent、DisplayArea、TaskDisplayArea等）都是WindowContainer的子类，而DisplayContent继承于DisplayArea，DisplayArea继承WindowContainer。所以这里首先执行的是DisplayArea的getItemFromTaskDisplayAreas。而TaskDisplayArea是DisplayContent的child，所以接下来会调用TaskDisplayArea的getItemFromTaskDisplayAreas，此时在递归深度优先获取到首个非空child后，会调用callbak。
由于getFocusedRootTask()传入的callback是TaskDisplayArea::getFocusedRootTask，这里是一个lamda语法，看下这个方法：
platform/frameworks/base/services/core/java/com/android/server/wm/TaskDisplayArea.java
Task getFocusedRootTask() {
if (mPreferredTopFocusableRootTask != null) {
return mPreferredTopFocusableRootTask;
}
for (int i = mChildren.size() - 1; i >= 0; --i) {
final WindowContainer child = mChildren.get(i);
if (child.asTaskDisplayArea() != null) {
final Task rootTask = child.asTaskDisplayArea().getFocusedRootTask();
if (rootTask != null) {
return rootTask;
}
continue;
}
final Task rootTask = mChildren.get(i).asTask();
if (rootTask.isFocusableAndVisible()) {
return rootTask;
}
}
return null;
}如果该TaskDisplayArea还有子TaskDisplayArea，那么会找子TaskDisplayArea的Task，否则就遍历当前TaskDisplayArea的子Task，找到isFocusableAndVisible的，返回。
这里的逻辑有点绕，关于窗口体系，请见Android12 - WMS之WindowContainer树（DisplayArea）-CSDN博客
复用Task
Task有嵌套关系。RootTask包含LeafTask。
回到startActivityInner，拿到prevTopRootTask后，Task prevTopTask = prevTopRootTask != null ? prevTopRootTask.getTopLeafTask() : null;
platform/frameworks/base/services/core/java/com/android/server/wm/Task.java
/** Return the top-most leaf-task under this one, or this task if it is a leaf. */
public Task getTopLeafTask() {
for (int i = mChildren.size() - 1; i >= 0; --i) {
final Task child = mChildren.get(i).asTask();
if (child == null) continue;
return child.getTopLeafTask();
}
return this;
}如果该prevTopRootTask有Child Task，则返回最顶部（最后加入的）Task，否则就返回自身。那么prevTopTask就是当前最顶部task。
final Task reusedTask = getReusableTask();获取可重复使用的Task。
/**
* Decide whether the new activity should be inserted into an existing task. Returns null
* if not or an ActivityRecord with the task into which the new activity should be added.
*/
private Task getReusableTask() {
// If a target task is specified, try to reuse that one
if (mOptions != null && mOptions.getLaunchTaskId() != INVALID_TASK_ID) {
Task launchTask = mRootWindowContainer.anyTaskForId(mOptions.getLaunchTaskId());
if (launchTask != null) {
return launchTask;
}
return null;
}
// We may want to try to place the new activity in to an existing task. We always
// do this if the target activity is singleTask or singleInstance; we will also do
// this if NEW_TASK has been requested, and there is not an additional qualifier telling
// us to still place it in a new task: multi task, always doc mode, or being asked to
// launch this as a new task behind the current one.
boolean putIntoExistingTask = ((mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0 &&
(mLaunchFlags & FLAG_ACTIVITY_MULTIPLE_TASK) == 0)
|| isLaunchModeOneOf(LAUNCH_SINGLE_INSTANCE, LAUNCH_SINGLE_TASK);
// If bring to front is requested, and no result is requested and we have not been given
// an explicit task to launch in to, and we can find a task that was started with this
// same component, then instead of launching bring that one to the front.
putIntoExistingTask &= mInTask == null && mStartActivity.resultTo == null;
ActivityRecord intentActivity = null;
if (putIntoExistingTask) {
if (LAUNCH_SINGLE_INSTANCE == mLaunchMode) {
// There can be one and only one instance of single instance activity in the
// history, and it is always in its own unique task, so we do a special search.
intentActivity = mRootWindowContainer.findActivity(mIntent, mStartActivity.info,
mStartActivity.isActivityTypeHome());
} else if ((mLaunchFlags & FLAG_ACTIVITY_LAUNCH_ADJACENT) != 0) {
// For the launch adjacent case we only want to put the activity in an existing
// task if the activity already exists in the history.
intentActivity = mRootWindowContainer.findActivity(mIntent, mStartActivity.info,
!(LAUNCH_SINGLE_TASK == mLaunchMode));
} else {
// Otherwise find the best task to put the activity in.
intentActivity =
mRootWindowContainer.findTask(mStartActivity, mPreferredTaskDisplayArea);
}
}
if (intentActivity != null && mLaunchMode == LAUNCH_SINGLE_INSTANCE_PER_TASK
&& !intentActivity.getTask().getRootActivity().mActivityComponent.equals(
mStartActivity.mActivityComponent)) {
// The task could be selected due to same task affinity. Do not reuse the task while
// starting the singleInstancePerTask activity if it is not the task root activity.
intentActivity = null;
}
if (intentActivity != null
&& (mStartActivity.isActivityTypeHome() || intentActivity.isActivityTypeHome())
&& intentActivity.getDisplayArea() != mPreferredTaskDisplayArea) {
// Do not reuse home activity on other display areas.
intentActivity = null;
}
return intentActivity != null ? intentActivity.getTask() : null;
}如果mOptions.getLaunchTaskId指定了复用的TaskId（通过在startActivity时指定ActivityOption），则直接返回。否则根据Intent flag判断是否需要使用已存在的task。
如果getReusableTask返回空，则继续使用computeTargetTask查看是否有可复用的task
platform/frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java
/** Returns the leaf task where the target activity may be placed. */
private Task computeTargetTask() {
if (mStartActivity.resultTo == null && mInTask == null && !mAddingToTask
&& (mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0) {
// A new task should be created instead of using existing one.
return null;
} else if (mSourceRecord != null) {
return mSourceRecord.getTask();
} else if (mInTask != null) {
// The task is specified from AppTaskImpl, so it may not be attached yet.
if (!mInTask.isAttached()) {
// Attach the task to display area. Ignore the returned root task (though usually
// they are the same) because "target task" should be leaf task.
getOrCreateRootTask(mStartActivity, mLaunchFlags, mInTask, mOptions);
}
return mInTask;
} else {
final Task rootTask = getOrCreateRootTask(mStartActivity, mLaunchFlags, null /* task */,
mOptions);
final ActivityRecord top = rootTask.getTopNonFinishingActivity();
if (top != null) {
return top.getTask();
} else {
// Remove the root task if no activity in the root task.
rootTask.removeIfPossible("computeTargetTask");
}
}
return null;
}从之前的参数整理部分，我们在我们启动的这个场景，resultTo和mInTask是空，此时mAddingToTask是false。如果用的是FLAG_ACTIVITY_NEW_TASK标签，则直接就放回null了。本方法的其他的条件中，也是想复用task。所以这个方法本意还是想复用。如果没有复用的话，mTargetRootTask还是空。
更新WindowingMode和mBounds
回到startActivityInner继续往下，在【位置3】处，调用了如下代码：
computeLaunchParams(r, sourceRecord, targetTask);
platform/frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java
private void computeLaunchParams(ActivityRecord r, ActivityRecord sourceRecord,
Task targetTask) {
mSupervisor.getLaunchParamsController().calculate(targetTask, r.info.windowLayout, r,
sourceRecord, mOptions, mRequest, PHASE_BOUNDS, mLaunchParams);
mPreferredTaskDisplayArea = mLaunchParams.hasPreferredTaskDisplayArea()
? mLaunchParams.mPreferredTaskDisplayArea
: mRootWindowContainer.getDefaultTaskDisplayArea();
mPreferredWindowingMode = mLaunchParams.mWindowingMode;
}这里看到，会再次调用mSupervisor.getLaunchParamsController().calculate， 二此时传入的phase是PHASE_BOUNDS。那么我们回到TaskLaunchParamsModifier.calculate方法。上次我们走到PHASE_DISPLAY后return了。这次继续往下走：
platform/frameworks/base/services/core/java/com/android/server/wm/TaskLaunchParamsModifier.java
private int calculate(@Nullable Task task, @Nullable ActivityInfo.WindowLayout layout,
@Nullable ActivityRecord activity, @Nullable ActivityRecord source,
@Nullable ActivityOptions options, @Nullable Request request, int phase,
LaunchParams currentParams, LaunchParams outParams) {
final ActivityRecord root;
if (task != null) {
root = task.getRootActivity() == null ? activity : task.getRootActivity();
} else {
root = activity;
}
if (root == null) {
// There is a case that can lead us here. The caller is moving the top activity that is
// in a task that has multiple activities to PIP mode. For that the caller is creating a
// new task to host the activity so that we only move the top activity to PIP mode and
// keep other activities in the previous task. There is no point to apply the launch
// logic in this case.
return RESULT_SKIP;
}
// STEP 1: Determine the suggested display area to launch the activity/task.
final TaskDisplayArea suggestedDisplayArea = getPreferredLaunchTaskDisplayArea(task,
options, source, currentParams, activity, request);
outParams.mPreferredTaskDisplayArea = suggestedDisplayArea;
final DisplayContent display = suggestedDisplayArea.mDisplayContent;
if (DEBUG) {
appendLog("display-id=" + display.getDisplayId()
+ " task-display-area-windowing-mode=" + suggestedDisplayArea.getWindowingMode()
+ " suggested-display-area=" + suggestedDisplayArea);
}
if (phase == PHASE_DISPLAY) {
return RESULT_CONTINUE;
}
// *** 本次我们继续往下执行
// STEP 2: Resolve launch windowing mode.
// STEP 2.1: Determine if any parameter can specify initial bounds/windowing mode. That
// might be the launch bounds from activity options, or size/gravity passed in layout. It
// also treats the launch windowing mode in options and source activity windowing mode in
// some cases as a suggestion for future resolution.
int launchMode = options != null ? options.getLaunchWindowingMode()
: WINDOWING_MODE_UNDEFINED;
// In some cases we want to use the source's windowing mode as the default value, e.g. when
// source is a freeform window in a fullscreen display launching an activity on the same
// display.
if (launchMode == WINDOWING_MODE_UNDEFINED
&& canInheritWindowingModeFromSource(display, suggestedDisplayArea, source)) {
// The source's windowing mode may be different from its task, e.g. activity is set
// to fullscreen and its task is pinned windowing mode when the activity is entering
// pip.
launchMode = source.getTask().getWindowingMode();
if (DEBUG) {
appendLog("inherit-from-source="
+ WindowConfiguration.windowingModeToString(launchMode));
}
}
// If the launch windowing mode is still undefined, inherit from the target task if the
// task is already on the right display area (otherwise, the task may be on a different
// display area that has incompatible windowing mode or the task organizer request to
// disassociate the leaf task if relaunched and reparented it to TDA as root task).
if (launchMode == WINDOWING_MODE_UNDEFINED
&& task != null && task.getTaskDisplayArea() == suggestedDisplayArea
&& !task.getRootTask().mReparentLeafTaskIfRelaunch) {
launchMode = task.getWindowingMode();
if (DEBUG) {
appendLog("inherit-from-task="
+ WindowConfiguration.windowingModeToString(launchMode));
}
}
// hasInitialBounds is set if either activity options or layout has specified bounds. If
// that's set we'll skip some adjustments later to avoid overriding the initial bounds.
boolean hasInitialBounds = false;
// hasInitialBoundsForSuggestedDisplayAreaInFreeformWindow is set if the outParams.mBounds
// is set with the suggestedDisplayArea. If it is set, but the eventual TaskDisplayArea is
// different, we should recalculating the bounds.
boolean hasInitialBoundsForSuggestedDisplayAreaInFreeformWindow = false;
// Note that initial bounds needs to be set to fullscreen tasks too as it's used as restore
// bounds.
final boolean canCalculateBoundsForFullscreenTask =
canCalculateBoundsForFullscreenTask(suggestedDisplayArea, launchMode);
final boolean canApplyFreeformWindowPolicy =
canApplyFreeformWindowPolicy(suggestedDisplayArea, launchMode);
final boolean canApplyWindowLayout = layout != null
&& (canApplyFreeformWindowPolicy || canCalculateBoundsForFullscreenTask);
final boolean canApplyBoundsFromActivityOptions =
mSupervisor.canUseActivityOptionsLaunchBounds(options)
&& (canApplyFreeformWindowPolicy
|| canApplyPipWindowPolicy(launchMode)
|| canCalculateBoundsForFullscreenTask);
if (canApplyBoundsFromActivityOptions) {
hasInitialBounds = true;
// |launchMode| at this point can be fullscreen, PIP, MultiWindow, etc. Only set
// freeform windowing mode if appropriate by checking |canApplyFreeformWindowPolicy|.
launchMode = launchMode == WINDOWING_MODE_UNDEFINED && canApplyFreeformWindowPolicy
? WINDOWING_MODE_FREEFORM
: launchMode;
outParams.mBounds.set(options.getLaunchBounds());
if (DEBUG) appendLog("activity-options-bounds=" + outParams.mBounds);
} else if (canApplyWindowLayout) {
mTmpBounds.set(currentParams.mBounds);
getLayoutBounds(suggestedDisplayArea, root, layout, mTmpBounds);
if (!mTmpBounds.isEmpty()) {
launchMode = canApplyFreeformWindowPolicy ? WINDOWING_MODE_FREEFORM : launchMode;
outParams.mBounds.set(mTmpBounds);
hasInitialBounds = true;
hasInitialBoundsForSuggestedDisplayAreaInFreeformWindow = true;
if (DEBUG) appendLog("bounds-from-layout=" + outParams.mBounds);
} else {
if (DEBUG) appendLog("empty-window-layout");
}
} else if (launchMode == WINDOWING_MODE_MULTI_WINDOW
&& options != null && options.getLaunchBounds() != null) {
// TODO: Investigate whether we can migrate this clause to the
// |canApplyBoundsFromActivityOptions| case above.
outParams.mBounds.set(options.getLaunchBounds());
hasInitialBounds = true;
if (DEBUG) appendLog("multiwindow-activity-options-bounds=" + outParams.mBounds);
}
// STEP 2.2: Check if previous modifier or the controller (referred as "callers" below) has
// some opinions on launch mode and launch bounds. If they have opinions and there is no
// initial bounds set in parameters. Note the check on display ID is also input param
// related because we always defer to callers' suggestion if there is no specific display ID
// in options or from source activity.
//
// If opinions from callers don't need any further resolution, we try to honor that as is as
// much as possible later.
// Flag to indicate if current param needs no further resolution. It's true it current
// param isn't freeform mode, or it already has launch bounds.
boolean fullyResolvedCurrentParam = false;
// We inherit launch params from previous modifiers or LaunchParamsController if options,
// layout and display conditions are not contradictory to their suggestions. It's important
// to carry over their values because LaunchParamsController doesn't automatically do that.
// We only check if display matches because display area can be changed later.
if (!currentParams.isEmpty() && !hasInitialBounds
&& (currentParams.mPreferredTaskDisplayArea == null
|| currentParams.mPreferredTaskDisplayArea.getDisplayId()
== display.getDisplayId())) {
// Only set windowing mode if display is in freeform. If the display is in fullscreen
// mode we should only launch a task in fullscreen mode.
if (currentParams.hasWindowingMode()
&& suggestedDisplayArea.inFreeformWindowingMode()) {
launchMode = currentParams.mWindowingMode;
fullyResolvedCurrentParam = launchMode != WINDOWING_MODE_FREEFORM;
if (DEBUG) {
appendLog("inherit-" + WindowConfiguration.windowingModeToString(launchMode));
}
}
if (!currentParams.mBounds.isEmpty()) {
// Carry over bounds from callers regardless of launch mode because bounds is still
// used to restore last non-fullscreen bounds when launch mode is not freeform.
outParams.mBounds.set(currentParams.mBounds);
fullyResolvedCurrentParam = true;
if (launchMode == WINDOWING_MODE_FREEFORM) {
if (DEBUG) appendLog("inherit-bounds=" + outParams.mBounds);
}
}
}
// STEP 2.3: Adjust launch parameters as needed for freeform display. We enforce the
// policies related to unresizable apps here. If an app is unresizable and the freeform
// size-compat mode is enabled, it can be launched in freeform depending on other properties
// such as orientation. Otherwise, the app is forcefully launched in maximized. The rest of
// this step is to define the default policy when there is no initial bounds or a fully
// resolved current params from callers.
// hasInitialBoundsForSuggestedDisplayAreaInFreeformMode is set if the outParams.mBounds
// is set with the suggestedDisplayArea. If it is set, but the eventual TaskDisplayArea is
// different, we should recalcuating the bounds.
boolean hasInitialBoundsForSuggestedDisplayAreaInFreeformMode = false;
if (suggestedDisplayArea.inFreeformWindowingMode()) {
if (launchMode == WINDOWING_MODE_PINNED) {
if (DEBUG) appendLog("picture-in-picture");
} else if (!root.isResizeable()) {
if (shouldLaunchUnresizableAppInFreeform(root, suggestedDisplayArea, options)) {
launchMode = WINDOWING_MODE_FREEFORM;
if (outParams.mBounds.isEmpty()) {
getTaskBounds(root, suggestedDisplayArea, layout, launchMode,
hasInitialBounds, outParams.mBounds);
hasInitialBoundsForSuggestedDisplayAreaInFreeformMode = true;
}
if (DEBUG) appendLog("unresizable-freeform");
} else {
launchMode = WINDOWING_MODE_FULLSCREEN;
outParams.mBounds.setEmpty();
if (DEBUG) appendLog("unresizable-forced-maximize");
}
}
} else {
if (DEBUG) appendLog("non-freeform-task-display-area");
}
// 更新WindoingMode，集成TaskDisplayArea的WindowMode
// If launch mode matches display windowing mode, let it inherit from display.
outParams.mWindowingMode = launchMode == suggestedDisplayArea.getWindowingMode()
? WINDOWING_MODE_UNDEFINED : launchMode;
if (phase == PHASE_WINDOWING_MODE) {
return RESULT_CONTINUE;
}
// STEP 3: Finalize the display area. Here we allow WM shell route all launches that match
// certain criteria to specific task display areas.
final int resolvedMode = (launchMode != WINDOWING_MODE_UNDEFINED) ? launchMode
: suggestedDisplayArea.getWindowingMode();
TaskDisplayArea taskDisplayArea = suggestedDisplayArea;
// If launch task display area is set in options we should just use it. We assume the
// suggestedDisplayArea has the right one in this case.
if (options == null || (options.getLaunchTaskDisplayArea() == null
&& options.getLaunchTaskDisplayAreaFeatureId() == FEATURE_UNDEFINED)) {
final int activityType =
mSupervisor.mRootWindowContainer.resolveActivityType(root, options, task);
display.forAllTaskDisplayAreas(displayArea -> {
final Task launchRoot = displayArea.getLaunchRootTask(
resolvedMode, activityType, null /* ActivityOptions */,
null /* sourceTask*/, 0 /* launchFlags */);
if (launchRoot == null) {
return false;
}
mTmpDisplayArea = displayArea;
return true;
});
// We may need to recalculate the bounds and the windowing mode if the new
// TaskDisplayArea is different from the suggested one we used to calculate the two
// configurations.
if (mTmpDisplayArea != null && mTmpDisplayArea != suggestedDisplayArea) {
outParams.mWindowingMode = (launchMode == mTmpDisplayArea.getWindowingMode())
? WINDOWING_MODE_UNDEFINED : launchMode;
if (hasInitialBoundsForSuggestedDisplayAreaInFreeformWindow) {
outParams.mBounds.setEmpty();
getLayoutBounds(mTmpDisplayArea, root, layout, outParams.mBounds);
hasInitialBounds = !outParams.mBounds.isEmpty();
} else if (hasInitialBoundsForSuggestedDisplayAreaInFreeformMode) {
outParams.mBounds.setEmpty();
getTaskBounds(root, mTmpDisplayArea, layout, launchMode,
hasInitialBounds, outParams.mBounds);
}
}
if (mTmpDisplayArea != null) {
taskDisplayArea = mTmpDisplayArea;
mTmpDisplayArea = null;
appendLog("overridden-display-area=["
+ WindowConfiguration.activityTypeToString(activityType) + ", "
+ WindowConfiguration.windowingModeToString(resolvedMode) + ", "
+ taskDisplayArea + "]");
}
}
appendLog("display-area=" + taskDisplayArea);
outParams.mPreferredTaskDisplayArea = taskDisplayArea;
if (phase == PHASE_DISPLAY_AREA) {
return RESULT_CONTINUE;
}
// STEP 4: Determine final launch bounds based on resolved windowing mode and activity
// requested orientation. We set bounds to empty for fullscreen mode and keep bounds as is
// for all other windowing modes that's not freeform mode. One can read comments in
// relevant methods to further understand this step.
//
// We skip making adjustments if the params are fully resolved from previous results.
if (fullyResolvedCurrentParam) {
if (resolvedMode == WINDOWING_MODE_FREEFORM) {
// Make sure bounds are in the displayArea.
if (currentParams.mPreferredTaskDisplayArea != taskDisplayArea) {
adjustBoundsToFitInDisplayArea(taskDisplayArea, layout, outParams.mBounds);
}
// Even though we want to keep original bounds, we still don't want it to stomp on
// an existing task.
adjustBoundsToAvoidConflictInDisplayArea(taskDisplayArea, outParams.mBounds);
}
} else {
if (source != null && source.inFreeformWindowingMode()
&& resolvedMode == WINDOWING_MODE_FREEFORM
&& outParams.mBounds.isEmpty()
&& source.getDisplayArea() == taskDisplayArea) {
// Set bounds to be not very far from source activity.
cascadeBounds(source.getConfiguration().windowConfiguration.getBounds(),
taskDisplayArea, outParams.mBounds);
}
getTaskBounds(root, taskDisplayArea, layout, resolvedMode, hasInitialBounds,
outParams.mBounds);
}
return RESULT_CONTINUE;
}首先，对outParams.mBounds进行了设置
outParams.mWindowingMode = launchMode == suggestedDisplayArea.getWindowingMode()
? WINDOWING_MODE_UNDEFINED : launchMode;
则对mWindowingMode进行了设置。这里沿用的是上层TaskDisplayArea的launchMode。
关于TaskDisplayArea的launchMode， 默认值来自DisplayConent的构造方法。在创建DisplayConent时，会调用setWindowingMode(WINDOWING_MODE_FULLSCREEN);
TaskDisplayArea创建Root Task
到目前，如果没有复用的话，mTargetRootTask还是空。所以会通过下面代码来创建新Task
if (mTargetRootTask == null) {
mTargetRootTask = getOrCreateRootTask(mStartActivity, mLaunchFlags, targetTask,
mOptions);
}getOrCreateRootTask会调用mRootWindowContainer.getOrCreateRootTask(r, aOptions, task, sourceTask, onTop, mLaunchParams, launchFlags);来创建Task：
Task getOrCreateRootTask(@Nullable ActivityRecord r,
@Nullable ActivityOptions options, @Nullable Task candidateTask,
@Nullable Task sourceTask, boolean onTop,
@Nullable LaunchParamsController.LaunchParams launchParams, int launchFlags) {
// First preference goes to the launch root task set in the activity options.
if (options != null) {
final Task candidateRoot = Task.fromWindowContainerToken(options.getLaunchRootTask());
if (candidateRoot != null && canLaunchOnDisplay(r, candidateRoot)) {
return candidateRoot;
}
}
// *** 位置1
// Next preference goes to the task id set in the activity options.
if (options != null) {
final int candidateTaskId = options.getLaunchTaskId();
if (candidateTaskId != INVALID_TASK_ID) {
// Temporarily set the task id to invalid in case in re-entry.
options.setLaunchTaskId(INVALID_TASK_ID);
final Task task = anyTaskForId(candidateTaskId,
MATCH_ATTACHED_TASK_OR_RECENT_TASKS_AND_RESTORE, options, onTop);
options.setLaunchTaskId(candidateTaskId);
if (canLaunchOnDisplay(r, task)) {
return task.getRootTask();
}
}
}
// *** 位置2
// Next preference goes to the TaskDisplayArea candidate from launchParams
// or activity options.
TaskDisplayArea taskDisplayArea = null;
if (launchParams != null && launchParams.mPreferredTaskDisplayArea != null) {
taskDisplayArea = launchParams.mPreferredTaskDisplayArea;
} else if (options != null) {
final WindowContainerToken daToken = options.getLaunchTaskDisplayArea();
taskDisplayArea = daToken != null
? (TaskDisplayArea) WindowContainer.fromBinder(daToken.asBinder()) : null;
if (taskDisplayArea == null) {
final int launchDisplayId = options.getLaunchDisplayId();
if (launchDisplayId != INVALID_DISPLAY) {
final DisplayContent displayContent = getDisplayContent(launchDisplayId);
if (displayContent != null) {
taskDisplayArea = displayContent.getDefaultTaskDisplayArea();
}
}
}
}
// *** 位置3
final int activityType = resolveActivityType(r, options, candidateTask);
// *** 位置4
if (taskDisplayArea != null) {
if (canLaunchOnDisplay(r, taskDisplayArea.getDisplayId())) {
// *** 位置5
return taskDisplayArea.getOrCreateRootTask(r, options, candidateTask,
sourceTask, launchParams, launchFlags, activityType, onTop);
} else {
taskDisplayArea = null;
}
}
// Give preference to the root task and display of the input task and activity if they
// match the mode we want to launch into.
Task rootTask = null;
if (candidateTask != null) {
rootTask = candidateTask.getRootTask();
}
if (rootTask == null && r != null) {
rootTask = r.getRootTask();
}
int windowingMode = launchParams != null ? launchParams.mWindowingMode
: WindowConfiguration.WINDOWING_MODE_UNDEFINED;
if (rootTask != null) {
taskDisplayArea = rootTask.getDisplayArea();
if (taskDisplayArea != null
&& canLaunchOnDisplay(r, taskDisplayArea.mDisplayContent.mDisplayId)) {
if (windowingMode == WindowConfiguration.WINDOWING_MODE_UNDEFINED) {
windowingMode = taskDisplayArea.resolveWindowingMode(r, options, candidateTask);
}
// Always allow organized tasks that created by organizer since the activity type
// of an organized task is decided by the activity type of its top child, which
// could be incompatible with the given windowing mode and activity type.
if (rootTask.isCompatible(windowingMode, activityType)
|| rootTask.mCreatedByOrganizer) {
return rootTask;
}
} else {
taskDisplayArea = null;
}
}
// Falling back to default task container
if (taskDisplayArea == null) {
taskDisplayArea = getDefaultTaskDisplayArea();
}
return taskDisplayArea.getOrCreateRootTask(r, options, candidateTask, sourceTask,
launchParams, launchFlags, activityType, onTop);
}这里是创建一个RootTask。
首先看位置1，candidateTaskId是空，就不复用了。位置2，launchParams.mPreferredTaskDisplayArea非空，为当前默认的DisplayContent下的TaskDisplayArea，于是taskDisplayArea的到赋值。位置3， activityType返回的是ACTIVITY_TYPE_STANDARD。
platform/frameworks/base/services/core/java/com/android/server/wm/RootWindowContainer.java
int resolveActivityType(@Nullable ActivityRecord r, @Nullable ActivityOptions options,
@Nullable Task task) {
// Preference is given to the activity type for the activity then the task since the type
// once set shouldn't change.
int activityType = r != null ? r.getActivityType() : ACTIVITY_TYPE_UNDEFINED;
if (activityType == ACTIVITY_TYPE_UNDEFINED && task != null) {
activityType = task.getActivityType();
}
if (activityType != ACTIVITY_TYPE_UNDEFINED) {
return activityType;
}
if (options != null) {
activityType = options.getLaunchActivityType();
}
return activityType != ACTIVITY_TYPE_UNDEFINED ? activityType : ACTIVITY_TYPE_STANDARD;
}位置4，canLaunchOnDisplay的检查，最终调用ActivityTaskSupervisor的canPlaceEntityOnDisplay：
platform/frameworks/base/services/core/java/com/android/server/wm/ActivityTaskSupervisor.java
private boolean canPlaceEntityOnDisplay(int displayId, int callingPid, int callingUid,
Task task, ActivityInfo activityInfo) {
if (displayId == DEFAULT_DISPLAY) {
// No restrictions for the default display.
return true;
}
if (!mService.mSupportsMultiDisplay) {
// Can't launch on secondary displays if feature is not supported.
return false;
}
if (!isCallerAllowedToLaunchOnDisplay(callingPid, callingUid, displayId, activityInfo)) {
// Can't place activities to a display that has restricted launch rules.
// In this case the request should be made by explicitly adding target display id and
// by caller with corresponding permissions. See #isCallerAllowedToLaunchOnDisplay().
return false;
}
final DisplayContent displayContent =
mRootWindowContainer.getDisplayContentOrCreate(displayId);
if (displayContent != null) {
final ArrayList<ActivityInfo> activities = new ArrayList<>();
if (activityInfo != null) {
activities.add(activityInfo);
}
if (task != null) {
task.forAllActivities((r) -> {
activities.add(r.info);
});
}
return displayContent.mDwpcHelper.canContainActivities(activities,
displayContent.getWindowingMode());
}
return true;
}这里是针对多屏幕情况下，Activity是否可在对应屏幕上启动的合法性检查。如果只有一块屏幕，返回true。
所以，最终会在位置5调用taskDisplayArea.getOrCreateRootTask来创建Root Task：
platform/frameworks/base/services/core/java/com/android/server/wm/TaskDisplayArea.java
Task getOrCreateRootTask(@Nullable ActivityRecord r, @Nullable ActivityOptions options,
@Nullable Task candidateTask, @Nullable Task sourceTask,
@Nullable LaunchParams launchParams, int launchFlags, int activityType, boolean onTop) {
int windowingMode = WINDOWING_MODE_UNDEFINED;
if (launchParams != null) {
// If launchParams isn't null, windowing mode is already resolved.
windowingMode = launchParams.mWindowingMode;
} else if (options != null) {
// If launchParams is null and options isn't let's use the windowing mode in the
// options.
windowingMode = options.getLaunchWindowingMode();
}
// Validate that our desired windowingMode will work under the current conditions.
// UNDEFINED windowing mode is a valid result and means that the new root task will inherit
// it's display's windowing mode.
windowingMode = validateWindowingMode(windowingMode, r, candidateTask);
return getOrCreateRootTask(windowingMode, activityType, onTop, candidateTask, sourceTask,
options, launchFlags);
}
/**
* When two level tasks are required for given windowing mode and activity type, returns an
* existing compatible root task or creates a new one.
* For one level task, the candidate task would be reused to also be the root task or create
* a new root task if no candidate task.
*
* @param windowingMode The windowing mode the root task should be created in.
* @param activityType The activityType the root task should be created in.
* @param onTop If true the root task will be created at the top of the display,
* else at the bottom.
* @param candidateTask The possible task the activity might be launched in. Can be null.
* @param sourceTask The task requesting to start activity. Used to determine which of the
* adjacent roots should be launch root of the new task. Can be null.
* @param options The activity options used to the launch. Can be null.
* @param launchFlags The launch flags for this launch.
* @return The root task to use for the launch.
* @see #getRootTask(int, int)
*/
Task getOrCreateRootTask(int windowingMode, int activityType, boolean onTop,
@Nullable Task candidateTask, @Nullable Task sourceTask,
@Nullable ActivityOptions options, int launchFlags) {
final int resolvedWindowingMode =
windowingMode == WINDOWING_MODE_UNDEFINED ? getWindowingMode() : windowingMode;
// Need to pass in a determined windowing mode to see if a new root task should be created,
// so use its parent's windowing mode if it is undefined.
if (!alwaysCreateRootTask(resolvedWindowingMode, activityType)) {
Task rootTask = getRootTask(resolvedWindowingMode, activityType);
if (rootTask != null) {
return rootTask;
}
} else if (candidateTask != null) {
final int position = onTop ? POSITION_TOP : POSITION_BOTTOM;
final Task launchParentTask = getLaunchRootTask(resolvedWindowingMode, activityType,
options, sourceTask, launchFlags, candidateTask);
if (launchParentTask != null) {
if (candidateTask.getParent() == null) {
launchParentTask.addChild(candidateTask, position);
} else if (candidateTask.getParent() != launchParentTask) {
candidateTask.reparent(launchParentTask, position);
}
} else if (candidateTask.getDisplayArea() != this
|| candidateTask.getRootTask().mReparentLeafTaskIfRelaunch) {
if (candidateTask.getParent() == null) {
addChild(candidateTask, position);
} else {
candidateTask.reparent(this, onTop);
}
}
// Update windowing mode if necessary, e.g. launch into a different windowing mode.
if (windowingMode != WINDOWING_MODE_UNDEFINED && candidateTask.isRootTask()
&& candidateTask.getWindowingMode() != windowingMode) {
candidateTask.mTransitionController.collect(candidateTask);
candidateTask.setWindowingMode(windowingMode);
}
return candidateTask.getRootTask();
}
return new Task.Builder(mAtmService)
.setWindowingMode(windowingMode)
.setActivityType(activityType)
.setOnTop(onTop)
.setParent(this)
.setSourceTask(sourceTask)
.setActivityOptions(options)
.setLaunchFlags(launchFlags)
.build();
}首先我们知道，本文场景下，launchParams.mWindowingMode之前的代码赋值为了WINDOWING_MODE_FULLSCREEN， 因此这里windowingMode为WINDOWING_MODE_FULLSCREEN。所以接下来alwaysCreateRootTask这里：
platform/frameworks/base/services/core/java/com/android/server/wm/DisplayContent.java
static boolean alwaysCreateRootTask(int windowingMode, int activityType) {
// Always create a root task for fullscreen, freeform, and multi windowing
// modes so that we can manage visual ordering and return types correctly.
return (activityType == ACTIVITY_TYPE_STANDARD || activityType == ACTIVITY_TYPE_RECENTS)
&& (windowingMode == WINDOWING_MODE_FULLSCREEN
|| windowingMode == WINDOWING_MODE_FREEFORM
|| windowingMode == WINDOWING_MODE_PINNED
|| windowingMode == WINDOWING_MODE_MULTI_WINDOW);
}由于前面知道activityType是ACTIVITY_TYPE_STANDARD， 所以本方法返回true。
在我们的场景candidateTask为空，因此会走Task.Builder(mAtmService)进行Task的创建。
看下Task.Builder的build方法：
Task build() {
if (mParent != null && mParent instanceof TaskDisplayArea) {
validateRootTask((TaskDisplayArea) mParent);
}
if (mActivityInfo == null) {
mActivityInfo = new ActivityInfo();
mActivityInfo.applicationInfo = new ApplicationInfo();
}
mUserId = UserHandle.getUserId(mActivityInfo.applicationInfo.uid);
mTaskAffiliation = mTaskId;
mLastTimeMoved = System.currentTimeMillis();
mNeverRelinquishIdentity = true;
mCallingUid = mActivityInfo.applicationInfo.uid;
mCallingPackage = mActivityInfo.packageName;
mResizeMode = mActivityInfo.resizeMode;
mSupportsPictureInPicture = mActivityInfo.supportsPictureInPicture();
if (!mRemoveWithTaskOrganizer && mActivityOptions != null) {
mRemoveWithTaskOrganizer = mActivityOptions.getRemoveWithTaskOranizer();
}
final Task task = buildInner();
task.mHasBeenVisible = mHasBeenVisible;
// Set activity type before adding the root task to TaskDisplayArea, so home task can
// be cached, see TaskDisplayArea#addRootTaskReferenceIfNeeded().
if (mActivityType != ACTIVITY_TYPE_UNDEFINED) {
task.setActivityType(mActivityType);
}
if (mParent != null) {
if (mParent instanceof Task) {
final Task parentTask = (Task) mParent;
parentTask.addChild(task, mOnTop ? POSITION_TOP : POSITION_BOTTOM,
(mActivityInfo.flags & FLAG_SHOW_FOR_ALL_USERS) != 0);
} else {
// ** 将本task加入到parent，也就是TaskDisplayArea的栈顶
mParent.addChild(task, mOnTop ? POSITION_TOP : POSITION_BOTTOM);
}
}
// Set windowing mode after attached to display area or it abort silently.
if (mWindowingMode != WINDOWING_MODE_UNDEFINED) {
task.setWindowingMode(mWindowingMode, true /* creating */);
}
return task;
}注意mParent.addChild将本task加入到了TaskDisplayArea的栈顶。
将Activity加入到Task
回到startActivityInner。getOrCreateRootTask()创建完Task后，紧接着判断newTask。因为前面newTask = targetTask == null， targetTast是指可复用的task，为空，所以这里newTask为true。因此紧接着调用setNewTask()。注意参数taskToAffiliate是null， 因为mSourceRecord是null。
platform/frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java
private void setNewTask(Task taskToAffiliate) {
final boolean toTop = !mLaunchTaskBehind && !mAvoidMoveToFront;
//返回mTargetRootTask自身
final Task task = mTargetRootTask.reuseOrCreateTask(
mStartActivity.info, mIntent, mVoiceSession,
mVoiceInteractor, toTop, mStartActivity, mSourceRecord, mOptions);
task.mTransitionController.collectExistenceChange(task);
// 将新new的activityRecord加入到mTargetRootTask
addOrReparentStartingActivity(task, "setTaskFromReuseOrCreateNewTask");
ProtoLog.v(WM_DEBUG_TASKS, "Starting new activity %s in new task %s",
mStartActivity, mStartActivity.getTask());
if (taskToAffiliate != null) {
mStartActivity.setTaskToAffiliateWith(taskToAffiliate);
}
}关注reuseOrCreateTask()方法， 其参数mStartActivity是之前新new的ActivityRecord， mIntent是客户端传过来intent， toTop为true：
platform/frameworks/base/services/core/java/com/android/server/wm/Task.java
Task reuseOrCreateTask(ActivityInfo info, Intent intent, IVoiceInteractionSession voiceSession,
IVoiceInteractor voiceInteractor, boolean toTop, ActivityRecord activity,
ActivityRecord source, ActivityOptions options) {
Task task;
if (canReuseAsLeafTask()) {
// 会走这里
// This root task will only contain one task, so just return itself since all root
// tasks ara now tasks and all tasks are now root tasks.
task = reuseAsLeafTask(voiceSession, voiceInteractor, intent, info, activity);
} else {
// Create child task since this root task can contain multiple tasks.
final int taskId = activity != null
? mTaskSupervisor.getNextTaskIdForUser(activity.mUserId)
: mTaskSupervisor.getNextTaskIdForUser();
final int activityType = getActivityType();
task = new Task.Builder(mAtmService)
.setTaskId(taskId)
.setActivityInfo(info)
.setActivityOptions(options)
.setIntent(intent)
.setVoiceSession(voiceSession)
.setVoiceInteractor(voiceInteractor)
.setOnTop(toTop)
.setParent(this)
.build();
}
int displayId = getDisplayId();
if (displayId == INVALID_DISPLAY) displayId = DEFAULT_DISPLAY;
final boolean isLockscreenShown = mAtmService.mTaskSupervisor.getKeyguardController()
.isKeyguardOrAodShowing(displayId);
if (!mTaskSupervisor.getLaunchParamsController()
.layoutTask(task, info.windowLayout, activity, source, options)
&& !getRequestedOverrideBounds().isEmpty()
&& task.isResizeable() && !isLockscreenShown) {
task.setBounds(getRequestedOverrideBounds());
}
return task;
}关注canReuseAsLeafTask()：
platform/frameworks/base/services/core/java/com/android/server/wm/Task.java
private boolean canReuseAsLeafTask() {
// Cannot be reused as leaf task if this task is created by organizer or having child tasks.
if (mCreatedByOrganizer || !isLeafTask()) {
return false;
}
// Existing Tasks can be reused if a new root task will be created anyway.
final int windowingMode = getWindowingMode();
final int activityType = getActivityType();
return DisplayContent.alwaysCreateRootTask(windowingMode, activityType);
}platform/frameworks/base/services/core/java/com/android/server/wm/Task.java
boolean isLeafTask() {
for (int i = mChildren.size() - 1; i >= 0; --i) {
if (mChildren.get(i).asTask() != null) {
return false;
}
}
return true;
}canReuseAsLeafTask()返回true。因为isLeafTask()是true（此时还没有mChildren），而DisplayContent.alwaysCreateRootTask之前看过，返回true。
所以会执行：
task = reuseAsLeafTask(voiceSession, voiceInteractor, intent, info, activity);
这句最终会返回task自身this。
整个setNewTask里的final Task task = mTargetRootTask.reuseOrCreateTask， 可以认为返回了mTargetRootTask自身，随后调用addOrReparentStartingActivity，把新new的mStartActivity加入到新new的mTargetRootTask
platform/frameworks/base/services/core/java/com/android/server/wm/Task.java
private void addOrReparentStartingActivity(@NonNull Task task, String reason) {
TaskFragment newParent = task;
if (mInTaskFragment != null) {
int embeddingCheckResult = canEmbedActivity(mInTaskFragment, mStartActivity, task);
if (embeddingCheckResult == EMBEDDING_ALLOWED) {
newParent = mInTaskFragment;
mStartActivity.mRequestedLaunchingTaskFragmentToken =
mInTaskFragment.getFragmentToken();
} else {
// Start mStartActivity to task instead if it can't be embedded to mInTaskFragment.
sendCanNotEmbedActivityError(mInTaskFragment, embeddingCheckResult);
}
} else {
TaskFragment candidateTf = mAddingToTaskFragment != null ? mAddingToTaskFragment : null;
if (candidateTf == null) {
// Puts the activity on the top-most non-isolated navigation TF, unless the
// activity is launched from the same TF.
final TaskFragment sourceTaskFragment =
mSourceRecord != null ? mSourceRecord.getTaskFragment() : null;
final ActivityRecord top = task.getActivity(r -> {
if (!r.canBeTopRunning()) {
return false;
}
final TaskFragment taskFragment = r.getTaskFragment();
return !taskFragment.isIsolatedNav() || (sourceTaskFragment != null
&& sourceTaskFragment == taskFragment);
});
if (top != null) {
candidateTf = top.getTaskFragment();
}
}
if (candidateTf != null && candidateTf.isEmbedded()
&& canEmbedActivity(candidateTf, mStartActivity, task) == EMBEDDING_ALLOWED) {
// Use the embedded TaskFragment of the top activity as the new parent if the
// activity can be embedded.
newParent = candidateTf;
}
}
if (mStartActivity.getTaskFragment() == null
|| mStartActivity.getTaskFragment() == newParent) {
newParent.addChild(mStartActivity, POSITION_TOP);
} else {
mStartActivity.reparent(newParent, newParent.getChildCount() /* top */, reason);
}
}此处TaskFragment newParent = task，getTaskFragment为null，newParent通过newParent.addChild(mStartActivity, POSITION_TOP)将activity加入task。
启动Activity
回到startActivityInner，来到位置4。由于上面的mTargetRootTask.startActivityLocked对整体流向没有影响，暂不讨论。下面看mDoResume条件满足内的逻辑：if (!mTargetRootTask.isTopActivityFocusable() ...。
platform/frameworks/base/services/core/java/com/android/server/wm/TaskFragment.java
boolean isTopActivityFocusable() {
final ActivityRecord r = topRunningActivity();
return r != null ? r.isFocusable()
: (isFocusable() && getWindowConfiguration().canReceiveKeys());
}由于mTargetRootTask此时是刚创建的，所以topRunningActivity是空。所以这里用task本身的isFocusable()，
platform/frameworks/base/services/core/java/com/android/server/wm/WindowContainer.java
boolean isFocusable() {
final WindowContainer parent = getParent();
return (parent == null || parent.isFocusable()) && mIsFocusable;
}由于mTargetRootTask自身的mIsFocusable属性默认是true，其parent TaskDisplayArea的isFocusable也是true，因此整体返回true。
那么startActivityInner里接下来就会走else分支里的mRootWindowContainer.resumeFocusedTasksTopActivities(
这里，activity将被启动。
2091
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
