Rename Stack to Task related terms (3/n)
Update most of methods and members with Stack terms in below files
- ActivityTaskManagerService
- RootWindowContainer
- ActivityTaskSupervisor
- DisplayContent
- TaskDisplayArea
No logical changes.
Bug: 157876447
Test: presubmit
Change-Id: I333c29916fa34fbccf9a7e172b79689b422259a3
diff --git a/services/core/java/com/android/server/wm/ActivityMetricsLogger.java b/services/core/java/com/android/server/wm/ActivityMetricsLogger.java
index b4ca7c5..6a50b79 100644
--- a/services/core/java/com/android/server/wm/ActivityMetricsLogger.java
+++ b/services/core/java/com/android/server/wm/ActivityMetricsLogger.java
@@ -425,20 +425,20 @@
mLastLogTimeSecs = now;
mWindowState = WINDOW_STATE_INVALID;
- Task stack = mSupervisor.mRootWindowContainer.getTopDisplayFocusedStack();
- if (stack == null) {
+ Task rootTask = mSupervisor.mRootWindowContainer.getTopDisplayFocusedRootTask();
+ if (rootTask == null) {
return;
}
- if (stack.isActivityTypeAssistant()) {
+ if (rootTask.isActivityTypeAssistant()) {
mWindowState = WINDOW_STATE_ASSISTANT;
return;
}
- @WindowingMode int windowingMode = stack.getWindowingMode();
+ @WindowingMode int windowingMode = rootTask.getWindowingMode();
if (windowingMode == WINDOWING_MODE_PINNED) {
- stack = mSupervisor.mRootWindowContainer.findStackBehind(stack);
- windowingMode = stack.getWindowingMode();
+ rootTask = mSupervisor.mRootWindowContainer.findRootTaskBehind(rootTask);
+ windowingMode = rootTask.getWindowingMode();
}
switch (windowingMode) {
case WINDOWING_MODE_FULLSCREEN:
@@ -456,7 +456,7 @@
break;
default:
if (windowingMode != WINDOWING_MODE_UNDEFINED) {
- throw new IllegalStateException("Unknown windowing mode for stack=" + stack
+ throw new IllegalStateException("Unknown windowing mode for task=" + rootTask
+ " windowingMode=" + windowingMode);
}
}
diff --git a/services/core/java/com/android/server/wm/ActivityRecord.java b/services/core/java/com/android/server/wm/ActivityRecord.java
index 75273ec..02643ef 100644
--- a/services/core/java/com/android/server/wm/ActivityRecord.java
+++ b/services/core/java/com/android/server/wm/ActivityRecord.java
@@ -2550,15 +2550,15 @@
return FINISH_RESULT_CANCELLED;
}
- final Task stack = getRootTask();
- final boolean mayAdjustTop = (isState(RESUMED) || stack.mResumedActivity == null)
- && stack.isFocusedStackOnDisplay()
+ final Task rootTask = getRootTask();
+ final boolean mayAdjustTop = (isState(RESUMED) || rootTask.mResumedActivity == null)
+ && rootTask.isFocusedStackOnDisplay()
// Do not adjust focus task because the task will be reused to launch new activity.
&& !task.isClearingToReuseTask();
final boolean shouldAdjustGlobalFocus = mayAdjustTop
// It must be checked before {@link #makeFinishingLocked} is called, because a stack
// is not visible if it only contains finishing activities.
- && mRootWindowContainer.isTopDisplayFocusedStack(stack);
+ && mRootWindowContainer.isTopDisplayFocusedRootTask(rootTask);
mAtmService.deferWindowLayout();
try {
@@ -2623,12 +2623,12 @@
// Tell window manager to prepare for this one to be removed.
setVisibility(false);
- if (stack.mPausingActivity == null) {
+ if (rootTask.mPausingActivity == null) {
ProtoLog.v(WM_DEBUG_STATES, "Finish needs to pause: %s", this);
if (DEBUG_USER_LEAVING) {
Slog.v(TAG_USER_LEAVING, "finish() => pause with userLeaving=false");
}
- stack.startPausingLocked(false /* userLeaving */, false /* uiSleeping */,
+ rootTask.startPausingLocked(false /* userLeaving */, false /* uiSleeping */,
null /* resuming */, "finish");
}
@@ -2827,7 +2827,7 @@
false /* markFrozenIfConfigChanged */, true /* deferResume */);
}
if (activityRemoved) {
- mRootWindowContainer.resumeFocusedStacksTopActivities();
+ mRootWindowContainer.resumeFocusedTasksTopActivities();
}
ProtoLog.d(WM_DEBUG_CONTAINERS, "destroyIfPossible: r=%s destroy returned "
@@ -2849,7 +2849,7 @@
mTaskSupervisor.mFinishingActivities.add(this);
}
resumeKeyDispatchingLocked();
- return mRootWindowContainer.resumeFocusedStacksTopActivities();
+ return mRootWindowContainer.resumeFocusedTasksTopActivities();
}
/**
@@ -3014,7 +3014,7 @@
removeFromHistory(reason);
}
- mRootWindowContainer.resumeFocusedStacksTopActivities();
+ mRootWindowContainer.resumeFocusedTasksTopActivities();
}
/**
@@ -5206,7 +5206,7 @@
} else {
if (deferRelaunchUntilPaused) {
destroyImmediately("stop-config");
- mRootWindowContainer.resumeFocusedStacksTopActivities();
+ mRootWindowContainer.resumeFocusedTasksTopActivities();
} else {
mRootWindowContainer.updatePreviousProcess(this);
}
@@ -5703,7 +5703,7 @@
// First find the real culprit... if this activity has stopped, then the key dispatching
// timeout should not be caused by this.
if (stopped) {
- final Task stack = mRootWindowContainer.getTopDisplayFocusedStack();
+ final Task stack = mRootWindowContainer.getTopDisplayFocusedRootTask();
if (stack == null) {
return this;
}
@@ -6091,7 +6091,7 @@
@Override
public void onAnimationLeashCreated(Transaction t, SurfaceControl leash) {
t.setLayer(leash, getAnimationLayer());
- getDisplayContent().assignStackOrdering();
+ getDisplayContent().assignRootTaskOrdering();
}
@Override
diff --git a/services/core/java/com/android/server/wm/ActivityStarter.java b/services/core/java/com/android/server/wm/ActivityStarter.java
index b88b54e..0bea251 100644
--- a/services/core/java/com/android/server/wm/ActivityStarter.java
+++ b/services/core/java/com/android/server/wm/ActivityStarter.java
@@ -664,7 +664,7 @@
synchronized (mService.mGlobalLock) {
final boolean globalConfigWillChange = mRequest.globalConfig != null
&& mService.getGlobalConfiguration().diff(mRequest.globalConfig) != 0;
- final Task stack = mRootWindowContainer.getTopDisplayFocusedStack();
+ final Task stack = mRootWindowContainer.getTopDisplayFocusedRootTask();
if (stack != null) {
stack.mConfigWillChange = globalConfigWillChange;
}
@@ -900,7 +900,7 @@
ActivityRecord sourceRecord = null;
ActivityRecord resultRecord = null;
if (resultTo != null) {
- sourceRecord = mRootWindowContainer.isInAnyStack(resultTo);
+ sourceRecord = mRootWindowContainer.isInAnyTask(resultTo);
if (DEBUG_RESULTS) {
Slog.v(TAG_RESULTS, "Will send result to " + resultTo + " " + sourceRecord);
}
@@ -1135,7 +1135,7 @@
if (DEBUG_PERMISSIONS_REVIEW) {
final Task focusedStack =
- mRootWindowContainer.getTopDisplayFocusedStack();
+ mRootWindowContainer.getTopDisplayFocusedRootTask();
Slog.i(TAG, "START u" + userId + " {" + intent.toShortString(true, true,
true, false) + "} from uid " + callingUid + " on display "
+ (focusedStack == null ? DEFAULT_DISPLAY
@@ -1175,7 +1175,7 @@
r.appTimeTracker = sourceRecord.appTimeTracker;
}
- final Task stack = mRootWindowContainer.getTopDisplayFocusedStack();
+ final Task stack = mRootWindowContainer.getTopDisplayFocusedRootTask();
// If we are starting an activity that is not from the same uid as the currently resumed
// one, check whether app switches are allowed.
@@ -1718,7 +1718,7 @@
// If the activity being launched is the same as the one currently at the top, then
// we need to check if it should only be launched once.
- final Task topStack = mRootWindowContainer.getTopDisplayFocusedStack();
+ final Task topStack = mRootWindowContainer.getTopDisplayFocusedRootTask();
if (topStack != null) {
startResult = deliverToCurrentTopIfNeeded(topStack, intentGrants);
if (startResult != START_SUCCESS) {
@@ -1806,14 +1806,14 @@
// task stack to be focusable, then ensure that we now update the focused stack
// accordingly.
if (mTargetStack.isTopActivityFocusable()
- && !mRootWindowContainer.isTopDisplayFocusedStack(mTargetStack)) {
+ && !mRootWindowContainer.isTopDisplayFocusedRootTask(mTargetStack)) {
mTargetStack.moveToFront("startActivityInner");
}
- mRootWindowContainer.resumeFocusedStacksTopActivities(
+ mRootWindowContainer.resumeFocusedTasksTopActivities(
mTargetStack, mStartActivity, mOptions);
}
}
- mRootWindowContainer.updateUserStack(mStartActivity.mUserId, mTargetStack);
+ mRootWindowContainer.updateUserRootTask(mStartActivity.mUserId, mTargetStack);
// Update the recent tasks list immediately when the activity starts
mSupervisor.mRecentTasks.add(mStartActivity.getTask());
@@ -1849,7 +1849,7 @@
private void computeLaunchParams(ActivityRecord r, ActivityRecord sourceRecord,
Task targetTask) {
final Task sourceStack = mSourceStack != null ? mSourceStack
- : mRootWindowContainer.getTopDisplayFocusedStack();
+ : mRootWindowContainer.getTopDisplayFocusedRootTask();
if (sourceStack != null && sourceStack.inSplitScreenWindowingMode()
&& (mOptions == null
|| mOptions.getLaunchWindowingMode() == WINDOWING_MODE_UNDEFINED)) {
@@ -2048,7 +2048,7 @@
// For paranoia, make sure we have correctly resumed the top activity.
topStack.mLastPausedActivity = null;
if (mDoResume) {
- mRootWindowContainer.resumeFocusedStacksTopActivities();
+ mRootWindowContainer.resumeFocusedTasksTopActivities();
}
ActivityOptions.abort(mOptions);
if ((mStartFlags & START_FLAG_ONLY_IF_NEEDED) != 0) {
@@ -2347,7 +2347,7 @@
if ((startFlags & START_FLAG_ONLY_IF_NEEDED) != 0) {
ActivityRecord checkedCaller = sourceRecord;
if (checkedCaller == null) {
- Task topFocusedStack = mRootWindowContainer.getTopDisplayFocusedStack();
+ Task topFocusedStack = mRootWindowContainer.getTopDisplayFocusedRootTask();
if (topFocusedStack != null) {
checkedCaller = topFocusedStack.topRunningNonDelayedActivityLocked(mNotTop);
}
@@ -2567,7 +2567,7 @@
// to the front if the caller is not itself in the front.
final boolean differentTopTask;
if (mTargetStack.getDisplayArea() == mPreferredTaskDisplayArea) {
- final Task focusStack = mTargetStack.mDisplayContent.getFocusedStack();
+ final Task focusStack = mTargetStack.mDisplayContent.getFocusedRootTask();
final ActivityRecord curTop = (focusStack == null)
? null : focusStack.topRunningNonDelayedActivityLocked(mNotTop);
final Task topTask = curTop != null ? curTop.getTask() : null;
@@ -2634,11 +2634,11 @@
if (next != null) {
next.setCurrentLaunchCanTurnScreenOn(true);
}
- mRootWindowContainer.resumeFocusedStacksTopActivities(mTargetStack, null, mOptions);
+ mRootWindowContainer.resumeFocusedTasksTopActivities(mTargetStack, null, mOptions);
} else {
ActivityOptions.abort(mOptions);
}
- mRootWindowContainer.updateUserStack(mStartActivity.mUserId, mTargetStack);
+ mRootWindowContainer.updateUserRootTask(mStartActivity.mUserId, mTargetStack);
}
private void setNewTask(Task taskToAffiliate) {
@@ -2713,7 +2713,7 @@
final boolean onTop =
(aOptions == null || !aOptions.getAvoidMoveToFront()) && !mLaunchTaskBehind;
- return mRootWindowContainer.getLaunchStack(r, aOptions, task, onTop, mLaunchParams,
+ return mRootWindowContainer.getLaunchRootTask(r, aOptions, task, onTop, mLaunchParams,
mRequest.realCallingPid, mRequest.realCallingUid);
}
diff --git a/services/core/java/com/android/server/wm/ActivityTaskManagerService.java b/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
index 8ba76be..3710120 100644
--- a/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
+++ b/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
@@ -1156,7 +1156,7 @@
synchronized (mGlobalLock) {
// If this is coming from the currently resumed activity, it is
// effectively saying that app switches are allowed at this point.
- final Task stack = getTopDisplayFocusedStack();
+ final Task stack = getTopDisplayFocusedRootTask();
if (stack != null && stack.mResumedActivity != null
&& stack.mResumedActivity.info.applicationInfo.uid == Binder.getCallingUid()) {
mAppSwitchesAllowedTime = 0;
@@ -1470,7 +1470,7 @@
sourceToken = resultTo;
}
- sourceRecord = mRootWindowContainer.isInAnyStack(sourceToken);
+ sourceRecord = mRootWindowContainer.isInAnyTask(sourceToken);
if (sourceRecord == null) {
throw new SecurityException("Called with bad activity token: " + sourceToken);
}
@@ -2039,7 +2039,7 @@
public boolean isTopActivityImmersive() {
enforceNotIsolatedCaller("isTopActivityImmersive");
synchronized (mGlobalLock) {
- final Task topFocusedStack = getTopDisplayFocusedStack();
+ final Task topFocusedStack = getTopDisplayFocusedRootTask();
if (topFocusedStack == null) {
return false;
}
@@ -2074,7 +2074,7 @@
public int getFrontActivityScreenCompatMode() {
enforceNotIsolatedCaller("getFrontActivityScreenCompatMode");
synchronized (mGlobalLock) {
- final Task stack = getTopDisplayFocusedStack();
+ final Task stack = getTopDisplayFocusedRootTask();
final ActivityRecord r = stack != null ? stack.topRunningActivity() : null;
if (r == null) {
return ActivityManager.COMPAT_MODE_UNKNOWN;
@@ -2089,7 +2089,7 @@
"setFrontActivityScreenCompatMode");
ApplicationInfo ai;
synchronized (mGlobalLock) {
- final Task stack = getTopDisplayFocusedStack();
+ final Task stack = getTopDisplayFocusedRootTask();
final ActivityRecord r = stack != null ? stack.topRunningActivity() : null;
if (r == null) {
Slog.w(TAG, "setFrontActivityScreenCompatMode failed: no top activity");
@@ -2165,7 +2165,7 @@
public void notifyActivityDrawn(IBinder token) {
if (DEBUG_VISIBILITY) Slog.d(TAG_VISIBILITY, "notifyActivityDrawn: token=" + token);
synchronized (mGlobalLock) {
- ActivityRecord r = mRootWindowContainer.isInAnyStack(token);
+ ActivityRecord r = mRootWindowContainer.isInAnyTask(token);
if (r != null) {
r.getRootTask().notifyActivityDrawnLocked(r);
}
@@ -2201,7 +2201,7 @@
final long ident = Binder.clearCallingIdentity();
try {
synchronized (mGlobalLock) {
- Task focusedStack = getTopDisplayFocusedStack();
+ Task focusedStack = getTopDisplayFocusedRootTask();
if (focusedStack != null) {
return mRootWindowContainer.getRootTaskInfo(focusedStack.mTaskId);
}
@@ -2219,14 +2219,14 @@
final long callingId = Binder.clearCallingIdentity();
try {
synchronized (mGlobalLock) {
- final Task task = mRootWindowContainer.getStack(taskId);
+ final Task task = mRootWindowContainer.getRootTask(taskId);
if (task == null) {
Slog.w(TAG, "setFocusedRootTask: No task with id=" + taskId);
return;
}
final ActivityRecord r = task.topRunningActivity();
if (r != null && r.moveFocusableActivityToTop("setFocusedRootTask")) {
- mRootWindowContainer.resumeFocusedStacksTopActivities();
+ mRootWindowContainer.resumeFocusedTasksTopActivities();
}
}
} finally {
@@ -2248,7 +2248,7 @@
}
final ActivityRecord r = task.topRunningActivityLocked();
if (r != null && r.moveFocusableActivityToTop("setFocusedTask")) {
- mRootWindowContainer.resumeFocusedStacksTopActivities();
+ mRootWindowContainer.resumeFocusedTasksTopActivities();
}
}
} finally {
@@ -2508,7 +2508,7 @@
synchronized (mGlobalLock) {
final long origId = Binder.clearCallingIdentity();
try {
- final Task topFocusedStack = getTopDisplayFocusedStack();
+ final Task topFocusedStack = getTopDisplayFocusedRootTask();
if (topFocusedStack != null) {
topFocusedStack.unhandledBackLocked();
}
@@ -2820,7 +2820,7 @@
ProtoLog.d(WM_DEBUG_TASKS, "moveTaskToRootTask: moving task=%d to "
+ "rootTaskId=%d toTop=%b", taskId, rootTaskId, toTop);
- final Task rootTask = mRootWindowContainer.getStack(rootTaskId);
+ final Task rootTask = mRootWindowContainer.getRootTask(rootTaskId);
if (rootTask == null) {
throw new IllegalStateException(
"moveTaskToRootTask: No rootTask for rootTaskId=" + rootTaskId);
@@ -3088,8 +3088,8 @@
return;
}
- final Task stack = mRootWindowContainer.getTopDisplayFocusedStack();
- if (stack == null || task != stack.getTopMostTask()) {
+ final Task rootTask = mRootWindowContainer.getTopDisplayFocusedRootTask();
+ if (rootTask == null || task != rootTask.getTopMostTask()) {
throw new IllegalArgumentException("Invalid task, not in foreground");
}
@@ -3370,7 +3370,7 @@
}
final Task stack = r.getRootTask();
- final Task task = stack.getDisplayArea().createStack(stack.getWindowingMode(),
+ final Task task = stack.getDisplayArea().createRootTask(stack.getWindowingMode(),
stack.getActivityType(), !ON_TOP, ainfo, intent,
false /* createdByOrganizer */);
@@ -3533,7 +3533,7 @@
try {
ProtoLog.d(WM_DEBUG_TASKS, "moveRootTaskToDisplay: moving taskId=%d to "
+ "displayId=%d", taskId, displayId);
- mRootWindowContainer.moveStackToDisplay(taskId, displayId, ON_TOP);
+ mRootWindowContainer.moveRootTaskToDisplay(taskId, displayId, ON_TOP);
} finally {
Binder.restoreCallingIdentity(ident);
}
@@ -3741,7 +3741,7 @@
"enqueueAssistContext()");
synchronized (mGlobalLock) {
- final Task stack = getTopDisplayFocusedStack();
+ final Task stack = getTopDisplayFocusedRootTask();
ActivityRecord activity = stack != null ? stack.getTopNonFinishingActivity() : null;
if (activity == null) {
Slog.w(TAG, "getAssistContextExtras failed: no top activity");
@@ -3870,7 +3870,7 @@
public boolean isAssistDataAllowedOnCurrentActivity() {
int userId;
synchronized (mGlobalLock) {
- final Task focusedStack = getTopDisplayFocusedStack();
+ final Task focusedStack = getTopDisplayFocusedRootTask();
if (focusedStack == null || focusedStack.isActivityTypeAssistant()) {
return false;
}
@@ -3890,7 +3890,7 @@
try {
synchronized (mGlobalLock) {
ActivityRecord caller = ActivityRecord.forTokenLocked(token);
- ActivityRecord top = getTopDisplayFocusedStack().getTopNonFinishingActivity();
+ ActivityRecord top = getTopDisplayFocusedRootTask().getTopNonFinishingActivity();
if (top != caller) {
Slog.w(TAG, "showAssistFromActivity failed: caller " + caller
+ " is not current top " + top);
@@ -4069,7 +4069,7 @@
final long ident = Binder.clearCallingIdentity();
try {
- return mRootWindowContainer.moveTopStackActivityToPinnedRootTask(rootTaskId);
+ return mRootWindowContainer.moveTopRootTaskActivityToPinnedRootTask(rootTaskId);
} finally {
Binder.restoreCallingIdentity(ident);
}
@@ -4113,7 +4113,7 @@
r.setPictureInPictureParams(params);
final float aspectRatio = r.pictureInPictureArgs.getAspectRatio();
final List<RemoteAction> actions = r.pictureInPictureArgs.getActions();
- mRootWindowContainer.moveActivityToPinnedStack(
+ mRootWindowContainer.moveActivityToPinnedRootTask(
r, "enterPictureInPictureMode");
final Task stack = r.getRootTask();
stack.setPictureInPictureAspectRatio(aspectRatio);
@@ -4345,7 +4345,7 @@
public void startLocalVoiceInteraction(IBinder callingActivity, Bundle options) {
Slog.i(TAG, "Activity tried to startLocalVoiceInteraction");
synchronized (mGlobalLock) {
- ActivityRecord activity = getTopDisplayFocusedStack().getTopNonFinishingActivity();
+ ActivityRecord activity = getTopDisplayFocusedRootTask().getTopNonFinishingActivity();
if (ActivityRecord.forTokenLocked(callingActivity) != activity) {
throw new SecurityException("Only focused activity can call startVoiceInteraction");
}
@@ -4749,7 +4749,7 @@
if (r.requestedVrComponent != null && r.getDisplayId() != DEFAULT_DISPLAY) {
Slog.i(TAG, "Moving " + r.shortComponentName + " from display " + r.getDisplayId()
+ " to main display for VR");
- mRootWindowContainer.moveStackToDisplay(
+ mRootWindowContainer.moveRootTaskToDisplay(
r.getRootTaskId(), DEFAULT_DISPLAY, true /* toTop */);
}
mH.post(() -> {
@@ -4813,8 +4813,8 @@
}
}
- Task getTopDisplayFocusedStack() {
- return mRootWindowContainer.getTopDisplayFocusedStack();
+ Task getTopDisplayFocusedRootTask() {
+ return mRootWindowContainer.getTopDisplayFocusedRootTask();
}
/** Pokes the task persister. */
@@ -5827,7 +5827,7 @@
/** Applies latest configuration and/or visibility updates if needed. */
boolean ensureConfigAndVisibilityAfterUpdate(ActivityRecord starting, int changes) {
boolean kept = true;
- final Task mainStack = mRootWindowContainer.getTopDisplayFocusedStack();
+ final Task mainStack = mRootWindowContainer.getTopDisplayFocusedRootTask();
// mainStack is null during startup.
if (mainStack != null) {
if (changes != 0 && starting == null) {
@@ -6082,8 +6082,8 @@
static final int REPORT_TIME_TRACKER_MSG = 1;
- static final int FIRST_ACTIVITY_STACK_MSG = 100;
- static final int FIRST_SUPERVISOR_STACK_MSG = 200;
+ static final int FIRST_ACTIVITY_TASK_MSG = 100;
+ static final int FIRST_SUPERVISOR_TASK_MSG = 200;
H(Looper looper) {
super(looper);
@@ -6292,7 +6292,7 @@
"setFocusedActivity: No activity record matching token=" + token);
}
if (r.moveFocusableActivityToTop("setFocusedActivity")) {
- mRootWindowContainer.resumeFocusedStacksTopActivities();
+ mRootWindowContainer.resumeFocusedTasksTopActivities();
}
}
}
@@ -6796,7 +6796,7 @@
if (!restarting && hasVisibleActivities) {
deferWindowLayout();
try {
- if (!mRootWindowContainer.resumeFocusedStacksTopActivities()) {
+ if (!mRootWindowContainer.resumeFocusedTasksTopActivities()) {
// If there was nothing to resume, and we are not already restarting
// this process, but there is a visible activity that is hosted by the
// process...then make sure all visible activities are running, taking
@@ -6849,7 +6849,7 @@
if (mRootWindowContainer.finishDisabledPackageActivities(
packageName, disabledClasses, true /* doit */, false /* evenPersistent */,
userId, false /* onlyRemoveNoProcess */) && booted) {
- mRootWindowContainer.resumeFocusedStacksTopActivities();
+ mRootWindowContainer.resumeFocusedTasksTopActivities();
mTaskSupervisor.scheduleIdle();
}
@@ -6879,7 +6879,7 @@
@Override
public void resumeTopActivities(boolean scheduleIdle) {
synchronized (mGlobalLock) {
- mRootWindowContainer.resumeFocusedStacksTopActivities();
+ mRootWindowContainer.resumeFocusedTasksTopActivities();
if (scheduleIdle) {
mTaskSupervisor.scheduleIdle();
}
@@ -7056,7 +7056,7 @@
mRootWindowContainer.dumpDisplayConfigs(pw, " ");
}
if (dumpAll) {
- final Task topFocusedStack = getTopDisplayFocusedStack();
+ final Task topFocusedStack = getTopDisplayFocusedRootTask();
if (dumpPackage == null && topFocusedStack != null) {
pw.println(" mConfigWillChange: " + topFocusedStack.mConfigWillChange);
}
@@ -7139,7 +7139,7 @@
synchronized (mGlobalLock) {
if (dumpPackage == null) {
getGlobalConfiguration().dumpDebug(proto, GLOBAL_CONFIGURATION);
- final Task topFocusedStack = getTopDisplayFocusedStack();
+ final Task topFocusedStack = getTopDisplayFocusedRootTask();
if (topFocusedStack != null) {
proto.write(CONFIG_WILL_CHANGE, topFocusedStack.mConfigWillChange);
}
diff --git a/services/core/java/com/android/server/wm/ActivityTaskSupervisor.java b/services/core/java/com/android/server/wm/ActivityTaskSupervisor.java
index d0c26af..d94c7af 100644
--- a/services/core/java/com/android/server/wm/ActivityTaskSupervisor.java
+++ b/services/core/java/com/android/server/wm/ActivityTaskSupervisor.java
@@ -63,7 +63,7 @@
import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_ATM;
import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_WITH_CLASS_NAME;
import static com.android.server.wm.ActivityTaskManagerService.ANIMATE;
-import static com.android.server.wm.ActivityTaskManagerService.H.FIRST_SUPERVISOR_STACK_MSG;
+import static com.android.server.wm.ActivityTaskManagerService.H.FIRST_SUPERVISOR_TASK_MSG;
import static com.android.server.wm.ActivityTaskManagerService.RELAUNCH_REASON_NONE;
import static com.android.server.wm.LockTaskController.LOCK_TASK_AUTH_ALLOWLISTED;
import static com.android.server.wm.LockTaskController.LOCK_TASK_AUTH_LAUNCHABLE;
@@ -176,18 +176,18 @@
/** How long we wait until giving up on the activity telling us it released the top state. */
private static final int TOP_RESUMED_STATE_LOSS_TIMEOUT = 500;
- private static final int IDLE_TIMEOUT_MSG = FIRST_SUPERVISOR_STACK_MSG;
- private static final int IDLE_NOW_MSG = FIRST_SUPERVISOR_STACK_MSG + 1;
- private static final int RESUME_TOP_ACTIVITY_MSG = FIRST_SUPERVISOR_STACK_MSG + 2;
- private static final int SLEEP_TIMEOUT_MSG = FIRST_SUPERVISOR_STACK_MSG + 3;
- private static final int LAUNCH_TIMEOUT_MSG = FIRST_SUPERVISOR_STACK_MSG + 4;
- private static final int PROCESS_STOPPING_AND_FINISHING_MSG = FIRST_SUPERVISOR_STACK_MSG + 5;
- private static final int LAUNCH_TASK_BEHIND_COMPLETE = FIRST_SUPERVISOR_STACK_MSG + 12;
- private static final int RESTART_ACTIVITY_PROCESS_TIMEOUT_MSG = FIRST_SUPERVISOR_STACK_MSG + 13;
- private static final int REPORT_MULTI_WINDOW_MODE_CHANGED_MSG = FIRST_SUPERVISOR_STACK_MSG + 14;
- private static final int REPORT_PIP_MODE_CHANGED_MSG = FIRST_SUPERVISOR_STACK_MSG + 15;
- private static final int START_HOME_MSG = FIRST_SUPERVISOR_STACK_MSG + 16;
- private static final int TOP_RESUMED_STATE_LOSS_TIMEOUT_MSG = FIRST_SUPERVISOR_STACK_MSG + 17;
+ private static final int IDLE_TIMEOUT_MSG = FIRST_SUPERVISOR_TASK_MSG;
+ private static final int IDLE_NOW_MSG = FIRST_SUPERVISOR_TASK_MSG + 1;
+ private static final int RESUME_TOP_ACTIVITY_MSG = FIRST_SUPERVISOR_TASK_MSG + 2;
+ private static final int SLEEP_TIMEOUT_MSG = FIRST_SUPERVISOR_TASK_MSG + 3;
+ private static final int LAUNCH_TIMEOUT_MSG = FIRST_SUPERVISOR_TASK_MSG + 4;
+ private static final int PROCESS_STOPPING_AND_FINISHING_MSG = FIRST_SUPERVISOR_TASK_MSG + 5;
+ private static final int LAUNCH_TASK_BEHIND_COMPLETE = FIRST_SUPERVISOR_TASK_MSG + 12;
+ private static final int RESTART_ACTIVITY_PROCESS_TIMEOUT_MSG = FIRST_SUPERVISOR_TASK_MSG + 13;
+ private static final int REPORT_MULTI_WINDOW_MODE_CHANGED_MSG = FIRST_SUPERVISOR_TASK_MSG + 14;
+ private static final int REPORT_PIP_MODE_CHANGED_MSG = FIRST_SUPERVISOR_TASK_MSG + 15;
+ private static final int START_HOME_MSG = FIRST_SUPERVISOR_TASK_MSG + 16;
+ private static final int TOP_RESUMED_STATE_LOSS_TIMEOUT_MSG = FIRST_SUPERVISOR_TASK_MSG + 17;
// Used to indicate that windows of activities should be preserved during the resize.
static final boolean PRESERVE_WINDOWS = true;
@@ -202,8 +202,8 @@
// Used to indicate that a task is removed it should also be removed from recents.
static final boolean REMOVE_FROM_RECENTS = true;
- /** True if the docked stack is currently being resized. */
- private boolean mDockedStackResizing;
+ /** True if the docked root task is currently being resized. */
+ private boolean mDockedRootTaskResizing;
// Activity actions an app cannot start if it uses a permission which is not granted.
private static final ArrayMap<String, String> ACTION_TO_RUNTIME_PERMISSION =
@@ -307,7 +307,7 @@
/** The target stack bounds for the picture-in-picture mode changed that we need to report to
* the application */
- private Rect mPipModeChangedTargetStackBounds;
+ private Rect mPipModeChangedTargetRootTaskBounds;
/** Used on user changes */
final ArrayList<UserState> mStartingUsers = new ArrayList<>();
@@ -386,17 +386,17 @@
final ActivityRecord r;
final ActivityRecord sourceRecord;
final int startFlags;
- final Task stack;
+ final Task rootTask;
final WindowProcessController callerApp;
final NeededUriGrants intentGrants;
PendingActivityLaunch(ActivityRecord r, ActivityRecord sourceRecord,
- int startFlags, Task stack, WindowProcessController callerApp,
+ int startFlags, Task rootTask, WindowProcessController callerApp,
NeededUriGrants intentGrants) {
this.r = r;
this.sourceRecord = sourceRecord;
this.startFlags = startFlags;
- this.stack = stack;
+ this.rootTask = rootTask;
this.callerApp = callerApp;
this.intentGrants = intentGrants;
}
@@ -501,11 +501,11 @@
getKeyguardController().setWindowManager(wm);
}
- void moveRecentsStackToFront(String reason) {
- final Task recentsStack = mRootWindowContainer.getDefaultTaskDisplayArea()
- .getStack(WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_RECENTS);
- if (recentsStack != null) {
- recentsStack.moveToFront(reason);
+ void moveRecentsRootTaskToFront(String reason) {
+ final Task recentsRootTask = mRootWindowContainer.getDefaultTaskDisplayArea()
+ .getRootTask(WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_RECENTS);
+ if (recentsRootTask != null) {
+ recentsRootTask.moveToFront(reason);
}
}
@@ -944,7 +944,7 @@
// launching the initial activity (that is, home), so that it can have
// a chance to initialize itself while in the background, making the
// switch back to it faster and look better.
- if (mRootWindowContainer.isTopDisplayFocusedStack(rootTask)) {
+ if (mRootWindowContainer.isTopDisplayFocusedRootTask(rootTask)) {
mService.getActivityStartController().startSetupActivity();
}
@@ -1376,10 +1376,10 @@
task.setBounds(bounds);
Task stack =
- mRootWindowContainer.getLaunchStack(null, options, task, ON_TOP);
+ mRootWindowContainer.getLaunchRootTask(null, options, task, ON_TOP);
if (stack != currentStack) {
- moveHomeStackToFrontIfNeeded(flags, stack.getDisplayArea(), reason);
+ moveHomeRootTaskToFrontIfNeeded(flags, stack.getDisplayArea(), reason);
task.reparent(stack, ON_TOP, REPARENT_KEEP_ROOT_TASK_AT_FRONT, !ANIMATE,
DEFER_RESUME, reason);
currentStack = stack;
@@ -1398,7 +1398,7 @@
}
if (!reparented) {
- moveHomeStackToFrontIfNeeded(flags, currentStack.getDisplayArea(), reason);
+ moveHomeRootTaskToFrontIfNeeded(flags, currentStack.getDisplayArea(), reason);
}
final ActivityRecord r = task.getTopNonFinishingActivity();
@@ -1412,16 +1412,16 @@
mRootWindowContainer.getDefaultTaskDisplayArea(), currentStack, forceNonResizeable);
}
- private void moveHomeStackToFrontIfNeeded(int flags, TaskDisplayArea taskDisplayArea,
+ private void moveHomeRootTaskToFrontIfNeeded(int flags, TaskDisplayArea taskDisplayArea,
String reason) {
- final Task focusedStack = taskDisplayArea.getFocusedStack();
+ final Task focusedRootTask = taskDisplayArea.getFocusedRootTask();
if ((taskDisplayArea.getWindowingMode() == WINDOWING_MODE_FULLSCREEN
&& (flags & ActivityManager.MOVE_TASK_WITH_HOME) != 0)
- || (focusedStack != null && focusedStack.isActivityTypeRecents())) {
+ || (focusedRootTask != null && focusedRootTask.isActivityTypeRecents())) {
// We move home stack to front when we are on a fullscreen display area and caller has
// requested the home activity to move with it. Or the previous stack is recents.
- taskDisplayArea.moveHomeStackToFront(reason);
+ taskDisplayArea.moveHomeRootTaskToFront(reason);
}
}
@@ -1441,15 +1441,15 @@
}
void setSplitScreenResizing(boolean resizing) {
- if (resizing == mDockedStackResizing) {
+ if (resizing == mDockedRootTaskResizing) {
return;
}
- mDockedStackResizing = resizing;
+ mDockedRootTaskResizing = resizing;
mWindowManager.setDockedStackResizing(resizing);
}
- private void removePinnedStackInSurfaceTransaction(Task stack) {
+ private void removePinnedRootTaskInSurfaceTransaction(Task rootTask) {
/**
* Workaround: Force-stop all the activities in the pinned stack before we reparent them
* to the fullscreen stack. This is to guarantee that when we are removing a stack,
@@ -1459,9 +1459,9 @@
* marked invisible as well and added to the stopping list. After which we process the
* stopping list by handling the idle.
*/
- stack.cancelAnimation();
- stack.setForceHidden(FLAG_FORCE_HIDDEN_FOR_PINNED_TASK, true /* set */);
- stack.ensureActivitiesVisible(null, 0, PRESERVE_WINDOWS);
+ rootTask.cancelAnimation();
+ rootTask.setForceHidden(FLAG_FORCE_HIDDEN_FOR_PINNED_TASK, true /* set */);
+ rootTask.ensureActivitiesVisible(null, 0, PRESERVE_WINDOWS);
activityIdleInternal(null /* idleActivity */, false /* fromTimeout */,
true /* processPausingActivities */, null /* configuration */);
@@ -1471,17 +1471,17 @@
mService.deferWindowLayout();
try {
- stack.setWindowingMode(WINDOWING_MODE_UNDEFINED);
- if (stack.getWindowingMode() != WINDOWING_MODE_FREEFORM) {
- stack.setBounds(null);
+ rootTask.setWindowingMode(WINDOWING_MODE_UNDEFINED);
+ if (rootTask.getWindowingMode() != WINDOWING_MODE_FREEFORM) {
+ rootTask.setBounds(null);
}
- toDisplay.getDefaultTaskDisplayArea().positionTaskBehindHome(stack);
+ toDisplay.getDefaultTaskDisplayArea().positionTaskBehindHome(rootTask);
// Follow on the workaround: activities are kept force hidden till the new windowing
// mode is set.
- stack.setForceHidden(FLAG_FORCE_HIDDEN_FOR_PINNED_TASK, false /* set */);
+ rootTask.setForceHidden(FLAG_FORCE_HIDDEN_FOR_PINNED_TASK, false /* set */);
mRootWindowContainer.ensureActivitiesVisible(null, 0, PRESERVE_WINDOWS);
- mRootWindowContainer.resumeFocusedStacksTopActivities();
+ mRootWindowContainer.resumeFocusedTasksTopActivities();
} finally {
mService.continueWindowLayout();
}
@@ -1489,7 +1489,7 @@
private void removeRootTaskInSurfaceTransaction(Task rootTask) {
if (rootTask.getWindowingMode() == WINDOWING_MODE_PINNED) {
- removePinnedStackInSurfaceTransaction(rootTask);
+ removePinnedRootTaskInSurfaceTransaction(rootTask);
} else {
final PooledConsumer c = PooledLambda.obtainConsumer(
ActivityTaskSupervisor::processRemoveTask, this, PooledLambda.__(Task.class));
@@ -1627,7 +1627,7 @@
*/
boolean restoreRecentTaskLocked(Task task, ActivityOptions aOptions, boolean onTop) {
final Task stack =
- mRootWindowContainer.getLaunchStack(null, aOptions, task, onTop);
+ mRootWindowContainer.getLaunchRootTask(null, aOptions, task, onTop);
final WindowContainer parent = task.getParent();
if (parent == stack || task == stack) {
@@ -1668,7 +1668,7 @@
* the various checks on tasks that are going to be reparented from one stack to another.
*/
// TODO: Look into changing users to this method to DisplayContent.resolveWindowingMode()
- Task getReparentTargetStack(Task task, Task stack, boolean toTop) {
+ Task getReparentTargetRootTask(Task task, Task stack, boolean toTop) {
final Task prevStack = task.getRootTask();
final int rootTaskId = stack.mTaskId;
final boolean inMultiWindowMode = stack.inMultiWindowMode();
@@ -1709,7 +1709,7 @@
if (prevStack != null) {
return prevStack;
}
- stack = stack.getDisplayArea().createStack(
+ stack = stack.getDisplayArea().createRootTask(
WINDOWING_MODE_FULLSCREEN, stack.getActivityType(), toTop);
}
return stack;
@@ -1739,7 +1739,7 @@
boolean timedout = false;
final long endTime = System.currentTimeMillis() + timeout;
while (true) {
- if (!mRootWindowContainer.putStacksToSleep(
+ if (!mRootWindowContainer.putTasksToSleep(
true /* allowDelay */, true /* shuttingDown */)) {
long timeRemaining = endTime - System.currentTimeMillis();
if (timeRemaining > 0) {
@@ -1776,7 +1776,7 @@
return;
}
- if (!mRootWindowContainer.putStacksToSleep(
+ if (!mRootWindowContainer.putTasksToSleep(
allowDelay, false /* shuttingDown */)) {
return;
}
@@ -1931,7 +1931,7 @@
mService.getLockTaskController().dump(pw, prefix);
pw.print(prefix);
pw.println("mCurTaskIdForUser=" + mCurTaskIdForUser);
- pw.println(prefix + "mUserStackInFront=" + mRootWindowContainer.mUserStackInFront);
+ pw.println(prefix + "mUserRootTaskInFront=" + mRootWindowContainer.mUserRootTaskInFront);
pw.println(prefix + "mVisibilityTransactionDepth=" + mVisibilityTransactionDepth);
if (!mWaitingForActivityVisible.isEmpty()) {
pw.println(prefix + "mWaitingForActivityVisible=");
@@ -2058,7 +2058,7 @@
*/
void updateTopResumedActivityIfNeeded() {
final ActivityRecord prevTopActivity = mTopResumedActivity;
- final Task topStack = mRootWindowContainer.getTopDisplayFocusedStack();
+ final Task topStack = mRootWindowContainer.getTopDisplayFocusedRootTask();
if (topStack == null || topStack.mResumedActivity == prevTopActivity) {
if (mService.isSleepingLocked()) {
// There won't be a next resumed activity. The top process should still be updated
@@ -2242,7 +2242,7 @@
}
}
- void logStackState() {
+ void logRootTaskState() {
mActivityMetricsLogger.logWindowState();
}
@@ -2281,7 +2281,7 @@
task.forAllActivities(c);
c.recycle();
- mPipModeChangedTargetStackBounds = targetStackBounds;
+ mPipModeChangedTargetRootTaskBounds = targetStackBounds;
if (!mHandler.hasMessages(REPORT_PIP_MODE_CHANGED_MSG)) {
mHandler.sendEmptyMessage(REPORT_PIP_MODE_CHANGED_MSG);
@@ -2436,7 +2436,7 @@
case REPORT_PIP_MODE_CHANGED_MSG: {
for (int i = mPipModeChangedActivities.size() - 1; i >= 0; i--) {
final ActivityRecord r = mPipModeChangedActivities.remove(i);
- r.updatePictureInPictureMode(mPipModeChangedTargetStackBounds,
+ r.updatePictureInPictureMode(mPipModeChangedTargetRootTaskBounds,
false /* forceUpdate */);
}
} break;
@@ -2452,7 +2452,7 @@
activityIdleFromMessage((ActivityRecord) msg.obj, false /* fromTimeout */);
} break;
case RESUME_TOP_ACTIVITY_MSG: {
- mRootWindowContainer.resumeFocusedStacksTopActivities();
+ mRootWindowContainer.resumeFocusedTasksTopActivities();
} break;
case SLEEP_TIMEOUT_MSG: {
if (mService.isSleepingOrShuttingDownLocked()) {
@@ -2542,7 +2542,7 @@
// from whatever is started from the recents activity, so move the home stack
// forward.
// TODO (b/115289124): Multi-display supports for recents.
- mRootWindowContainer.getDefaultTaskDisplayArea().moveHomeStackToFront(
+ mRootWindowContainer.getDefaultTaskDisplayArea().moveHomeRootTaskToFront(
"startActivityFromRecents");
}
diff --git a/services/core/java/com/android/server/wm/CompatModePackages.java b/services/core/java/com/android/server/wm/CompatModePackages.java
index 4b34954..c22bd20 100644
--- a/services/core/java/com/android/server/wm/CompatModePackages.java
+++ b/services/core/java/com/android/server/wm/CompatModePackages.java
@@ -17,10 +17,10 @@
package com.android.server.wm;
import static com.android.internal.protolog.ProtoLogGroup.WM_DEBUG_CONFIGURATION;
-import static com.android.server.wm.ActivityTaskSupervisor.PRESERVE_WINDOWS;
import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_CONFIGURATION;
import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_ATM;
import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_WITH_CLASS_NAME;
+import static com.android.server.wm.ActivityTaskSupervisor.PRESERVE_WINDOWS;
import android.app.ActivityManager;
import android.app.AppGlobals;
@@ -313,7 +313,7 @@
scheduleWrite();
- final Task stack = mService.getTopDisplayFocusedStack();
+ final Task stack = mService.getTopDisplayFocusedRootTask();
ActivityRecord starting = stack.restartPackage(packageName);
// Tell all processes that loaded this package about the change.
diff --git a/services/core/java/com/android/server/wm/DisplayContent.java b/services/core/java/com/android/server/wm/DisplayContent.java
index 058258d..0985f56 100644
--- a/services/core/java/com/android/server/wm/DisplayContent.java
+++ b/services/core/java/com/android/server/wm/DisplayContent.java
@@ -1320,7 +1320,7 @@
false /* deferResume */, null /* result */);
activityRecord.frozenBeforeDestroy = true;
if (!kept) {
- mRootWindowContainer.resumeFocusedStacksTopActivities();
+ mRootWindowContainer.resumeFocusedTasksTopActivities();
}
} else {
// We have a new configuration to push so we need to update ATMS for now.
@@ -2221,26 +2221,26 @@
* activity type. Null is no compatible stack on the display.
*/
@Nullable
- Task getStack(int windowingMode, int activityType) {
+ Task getRootTask(int windowingMode, int activityType) {
return getItemFromTaskDisplayAreas(taskDisplayArea ->
- taskDisplayArea.getStack(windowingMode, activityType));
+ taskDisplayArea.getRootTask(windowingMode, activityType));
}
@Nullable
- Task getStack(int rootTaskId) {
+ Task getRootTask(int rootTaskId) {
return getItemFromTaskDisplayAreas(taskDisplayArea ->
- taskDisplayArea.getStack(rootTaskId));
+ taskDisplayArea.getRootTask(rootTaskId));
}
- protected int getStackCount() {
+ protected int getRootTaskCount() {
return reduceOnAllTaskDisplayAreas((taskDisplayArea, count) ->
- count + taskDisplayArea.getStackCount(), 0 /* initValue */);
+ count + taskDisplayArea.getRootTaskCount(), 0 /* initValue */);
}
@VisibleForTesting
@Nullable
- Task getTopStack() {
- return getItemFromTaskDisplayAreas(TaskDisplayArea::getTopStack);
+ Task getTopRootTask() {
+ return getItemFromTaskDisplayAreas(TaskDisplayArea::getTopRootTask);
}
/**
@@ -2904,7 +2904,7 @@
mClosingApps.valueAt(i).writeIdentifierToProto(proto, CLOSING_APPS);
}
- final Task focusedStack = getFocusedStack();
+ final Task focusedStack = getFocusedRootTask();
if (focusedStack != null) {
proto.write(FOCUSED_ROOT_TASK_ID, focusedStack.getRootTaskId());
final ActivityRecord focusedActivity = focusedStack.getDisplayArea()
@@ -2948,7 +2948,7 @@
public void dump(PrintWriter pw, String prefix, boolean dumpAll) {
super.dump(pw, prefix, dumpAll);
pw.print(prefix);
- pw.println("Display: mDisplayId=" + mDisplayId + " stacks=" + getStackCount());
+ pw.println("Display: mDisplayId=" + mDisplayId + " stacks=" + getRootTaskCount());
final String subPrefix = " " + prefix;
pw.print(subPrefix); pw.print("init="); pw.print(mInitialDisplayWidth); pw.print("x");
pw.print(mInitialDisplayHeight); pw.print(" "); pw.print(mInitialDisplayDensity);
@@ -3046,13 +3046,13 @@
pw.println(prefix + "splitScreenPrimaryStack=" + splitScreenPrimaryStack.getName());
}
// TODO: Support recents on non-default task containers
- final Task recentsStack = getDefaultTaskDisplayArea().getStack(
+ final Task recentsStack = getDefaultTaskDisplayArea().getRootTask(
WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_RECENTS);
if (recentsStack != null) {
pw.println(prefix + "recentsStack=" + recentsStack.getName());
}
final Task dreamStack =
- getStack(WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_DREAM);
+ getRootTask(WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_DREAM);
if (dreamStack != null) {
pw.println(prefix + "dreamStack=" + dreamStack.getName());
}
@@ -4494,9 +4494,9 @@
}
}
- void assignStackOrdering() {
+ void assignRootTaskOrdering() {
forAllTaskDisplayAreas(taskDisplayArea -> {
- taskDisplayArea.assignStackOrdering(getPendingTransaction());
+ taskDisplayArea.assignRootTaskOrdering(getPendingTransaction());
});
}
@@ -5061,7 +5061,7 @@
mWmService.requestTraversal();
}
- static boolean alwaysCreateStack(int windowingMode, int activityType) {
+ static boolean alwaysCreateRootTask(int windowingMode, int activityType) {
// Always create a stack for fullscreen, freeform, and split-screen-secondary windowing
// modes so that we can manage visual ordering and return types correctly.
return activityType == ACTIVITY_TYPE_STANDARD
@@ -5075,13 +5075,13 @@
static boolean canReuseExistingTask(int windowingMode, int activityType) {
// Existing Tasks can be reused if a new stack will be created anyway, or for the Dream -
// because there can only ever be one DreamActivity.
- return alwaysCreateStack(windowingMode, activityType)
+ return alwaysCreateRootTask(windowingMode, activityType)
|| activityType == ACTIVITY_TYPE_DREAM;
}
@Nullable
- Task getFocusedStack() {
- return getItemFromTaskDisplayAreas(TaskDisplayArea::getFocusedStack);
+ Task getFocusedRootTask() {
+ return getItemFromTaskDisplayAreas(TaskDisplayArea::getFocusedRootTask);
}
/**
@@ -5318,19 +5318,19 @@
// Check if all task display areas have only the empty home stacks left.
boolean hasNonEmptyHomeStack = forAllTaskDisplayAreas(taskDisplayArea -> {
- if (taskDisplayArea.getStackCount() != 1) {
+ if (taskDisplayArea.getRootTaskCount() != 1) {
return true;
}
- final Task stack = taskDisplayArea.getStackAt(0);
+ final Task stack = taskDisplayArea.getRootTaskAt(0);
return !stack.isActivityTypeHome() || stack.hasChild();
});
if (!hasNonEmptyHomeStack) {
// Release this display if only empty home stack(s) are left. This display will be
// released along with the stack(s) removal.
forAllTaskDisplayAreas(taskDisplayArea -> {
- taskDisplayArea.getStackAt(0).removeIfPossible();
+ taskDisplayArea.getRootTaskAt(0).removeIfPossible();
});
- } else if (getTopStack() == null) {
+ } else if (getTopRootTask() == null) {
removeIfPossible();
mRootWindowContainer.mTaskSupervisor
.getKeyguardController().onDisplayRemoved(mDisplayId);
@@ -5357,7 +5357,7 @@
}
boolean shouldSleep() {
- return (getStackCount() == 0 || !mAllSleepTokens.isEmpty())
+ return (getRootTaskCount() == 0 || !mAllSleepTokens.isEmpty())
&& (mAtmService.mRunningVoice == null);
}
diff --git a/services/core/java/com/android/server/wm/DisplayPolicy.java b/services/core/java/com/android/server/wm/DisplayPolicy.java
index 826b725..2ddd001 100644
--- a/services/core/java/com/android/server/wm/DisplayPolicy.java
+++ b/services/core/java/com/android/server/wm/DisplayPolicy.java
@@ -2046,7 +2046,7 @@
// requests to hide the status bar. Not sure if there is another way that to be the
// case though.
if (!topIsFullscreen || mDisplayContent.getDefaultTaskDisplayArea()
- .isStackVisible(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY)) {
+ .isRootTaskVisible(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY)) {
topAppHidesStatusBar = false;
}
}
@@ -2830,9 +2830,9 @@
private int updateSystemBarsLw(WindowState win, int disableFlags) {
final boolean dockedStackVisible = mDisplayContent.getDefaultTaskDisplayArea()
- .isStackVisible(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY);
+ .isRootTaskVisible(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY);
final boolean freeformStackVisible = mDisplayContent.getDefaultTaskDisplayArea()
- .isStackVisible(WINDOWING_MODE_FREEFORM);
+ .isRootTaskVisible(WINDOWING_MODE_FREEFORM);
final boolean resizing = mDisplayContent.getDockedDividerController().isResizing();
// We need to force system bars when the docked stack is visible, when the freeform stack
diff --git a/services/core/java/com/android/server/wm/InsetsPolicy.java b/services/core/java/com/android/server/wm/InsetsPolicy.java
index d308766..ee150c3 100644
--- a/services/core/java/com/android/server/wm/InsetsPolicy.java
+++ b/services/core/java/com/android/server/wm/InsetsPolicy.java
@@ -392,9 +392,9 @@
private boolean forceShowsSystemBarsForWindowingMode() {
final boolean isDockedStackVisible = mDisplayContent.getDefaultTaskDisplayArea()
- .isStackVisible(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY);
+ .isRootTaskVisible(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY);
final boolean isFreeformStackVisible = mDisplayContent.getDefaultTaskDisplayArea()
- .isStackVisible(WINDOWING_MODE_FREEFORM);
+ .isRootTaskVisible(WINDOWING_MODE_FREEFORM);
final boolean isResizing = mDisplayContent.getDockedDividerController().isResizing();
// We need to force system bars when the docked stack is visible, when the freeform stack
diff --git a/services/core/java/com/android/server/wm/KeyguardController.java b/services/core/java/com/android/server/wm/KeyguardController.java
index ebd91a0..e45310a 100644
--- a/services/core/java/com/android/server/wm/KeyguardController.java
+++ b/services/core/java/com/android/server/wm/KeyguardController.java
@@ -211,7 +211,7 @@
updateKeyguardSleepToken();
// Some stack visibility might change (e.g. docked stack)
- mRootWindowContainer.resumeFocusedStacksTopActivities();
+ mRootWindowContainer.resumeFocusedTasksTopActivities();
mRootWindowContainer.ensureActivitiesVisible(null, 0, !PRESERVE_WINDOWS);
mRootWindowContainer.addStartingWindowsForVisibleActivities();
mWindowManager.executeAppTransition();
@@ -595,8 +595,8 @@
@Nullable
private Task getRootTaskForControllingOccluding(DisplayContent display) {
return display.getItemFromTaskDisplayAreas(taskDisplayArea -> {
- for (int sNdx = taskDisplayArea.getStackCount() - 1; sNdx >= 0; --sNdx) {
- final Task task = taskDisplayArea.getStackAt(sNdx);
+ for (int sNdx = taskDisplayArea.getRootTaskCount() - 1; sNdx >= 0; --sNdx) {
+ final Task task = taskDisplayArea.getRootTaskAt(sNdx);
if (task != null && task.isFocusableAndVisible()
&& !task.inPinnedWindowingMode()) {
return task;
diff --git a/services/core/java/com/android/server/wm/LaunchParamsController.java b/services/core/java/com/android/server/wm/LaunchParamsController.java
index b6b172e..8745e95 100644
--- a/services/core/java/com/android/server/wm/LaunchParamsController.java
+++ b/services/core/java/com/android/server/wm/LaunchParamsController.java
@@ -143,7 +143,7 @@
try {
if (mTmpParams.mPreferredTaskDisplayArea != null
&& task.getDisplayArea() != mTmpParams.mPreferredTaskDisplayArea) {
- mService.mRootWindowContainer.moveStackToTaskDisplayArea(task.getRootTaskId(),
+ mService.mRootWindowContainer.moveRootTaskToTaskDisplayArea(task.getRootTaskId(),
mTmpParams.mPreferredTaskDisplayArea, true /* onTop */);
}
diff --git a/services/core/java/com/android/server/wm/LockTaskController.java b/services/core/java/com/android/server/wm/LockTaskController.java
index ee39787..4b3a434 100644
--- a/services/core/java/com/android/server/wm/LockTaskController.java
+++ b/services/core/java/com/android/server/wm/LockTaskController.java
@@ -504,7 +504,7 @@
return;
}
task.performClearTaskLocked();
- mSupervisor.mRootWindowContainer.resumeFocusedStacksTopActivities();
+ mSupervisor.mRootWindowContainer.resumeFocusedTasksTopActivities();
}
/**
@@ -640,7 +640,7 @@
if (andResume) {
mSupervisor.findTaskToMoveToFront(task, 0, null, reason,
lockTaskModeState != LOCK_TASK_MODE_NONE);
- mSupervisor.mRootWindowContainer.resumeFocusedStacksTopActivities();
+ mSupervisor.mRootWindowContainer.resumeFocusedTasksTopActivities();
final Task rootTask = task.getRootTask();
if (rootTask != null) {
rootTask.mDisplayContent.executeAppTransition();
@@ -717,7 +717,7 @@
}
if (taskChanged) {
- mSupervisor.mRootWindowContainer.resumeFocusedStacksTopActivities();
+ mSupervisor.mRootWindowContainer.resumeFocusedTasksTopActivities();
}
}
diff --git a/services/core/java/com/android/server/wm/RecentTasks.java b/services/core/java/com/android/server/wm/RecentTasks.java
index ba6b27a..5598937 100644
--- a/services/core/java/com/android/server/wm/RecentTasks.java
+++ b/services/core/java/com/android/server/wm/RecentTasks.java
@@ -36,13 +36,13 @@
import static android.os.Process.SYSTEM_UID;
import static com.android.internal.protolog.ProtoLogGroup.WM_DEBUG_TASKS;
-import static com.android.server.wm.ActivityTaskSupervisor.REMOVE_FROM_RECENTS;
import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_RECENTS;
import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_RECENTS_TRIM_TASKS;
import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_RECENTS;
import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_TASKS;
import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_ATM;
import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_WITH_CLASS_NAME;
+import static com.android.server.wm.ActivityTaskSupervisor.REMOVE_FROM_RECENTS;
import android.annotation.Nullable;
import android.app.ActivityManager;
@@ -220,7 +220,7 @@
final RootWindowContainer rac = mService.mRootWindowContainer;
final DisplayContent dc = rac.getDisplayContent(displayId).mDisplayContent;
if (dc.pointWithinAppWindow(x, y)) {
- final Task stack = mService.getTopDisplayFocusedStack();
+ final Task stack = mService.getTopDisplayFocusedRootTask();
final Task topTask = stack != null ? stack.getTopMostTask() : null;
resetFreezeTaskListReordering(topTask);
}
@@ -328,7 +328,7 @@
@VisibleForTesting
void resetFreezeTaskListReorderingOnTimeout() {
synchronized (mService.mGlobalLock) {
- final Task focusedStack = mService.getTopDisplayFocusedStack();
+ final Task focusedStack = mService.getTopDisplayFocusedRootTask();
final Task topTask = focusedStack != null ? focusedStack.getTopMostTask() : null;
resetFreezeTaskListReordering(topTask);
}
diff --git a/services/core/java/com/android/server/wm/RecentsAnimation.java b/services/core/java/com/android/server/wm/RecentsAnimation.java
index 823dc51..067c772 100644
--- a/services/core/java/com/android/server/wm/RecentsAnimation.java
+++ b/services/core/java/com/android/server/wm/RecentsAnimation.java
@@ -29,7 +29,7 @@
import static com.android.server.wm.RecentsAnimationController.REORDER_KEEP_IN_PLACE;
import static com.android.server.wm.RecentsAnimationController.REORDER_MOVE_TO_ORIGINAL_POSITION;
import static com.android.server.wm.RecentsAnimationController.REORDER_MOVE_TO_TOP;
-import static com.android.server.wm.TaskDisplayArea.getStackAbove;
+import static com.android.server.wm.TaskDisplayArea.getRootTaskAbove;
import android.annotation.Nullable;
import android.app.ActivityOptions;
@@ -45,13 +45,13 @@
import com.android.internal.util.function.pooled.PooledPredicate;
import com.android.server.wm.ActivityMetricsLogger.LaunchingState;
import com.android.server.wm.RecentsAnimationController.RecentsAnimationCallbacks;
+import com.android.server.wm.TaskDisplayArea.OnRootTaskOrderChangedListener;
/**
* Manages the recents animation, including the reordering of the stacks for the transition and
* cleanup. See {@link com.android.server.wm.RecentsAnimationController}.
*/
-class RecentsAnimation implements RecentsAnimationCallbacks,
- TaskDisplayArea.OnStackOrderChangedListener {
+class RecentsAnimation implements RecentsAnimationCallbacks, OnRootTaskOrderChangedListener {
private static final String TAG = RecentsAnimation.class.getSimpleName();
private final ActivityTaskManagerService mService;
@@ -106,7 +106,7 @@
void preloadRecentsActivity() {
ProtoLog.d(WM_DEBUG_RECENTS_ANIMATIONS, "Preload recents with %s",
mTargetIntent);
- Task targetStack = mDefaultTaskDisplayArea.getStack(WINDOWING_MODE_UNDEFINED,
+ Task targetStack = mDefaultTaskDisplayArea.getRootTask(WINDOWING_MODE_UNDEFINED,
mTargetActivityType);
ActivityRecord targetActivity = getTargetActivity(targetStack);
if (targetActivity != null) {
@@ -127,7 +127,7 @@
// Create the activity record. Because the activity is invisible, this doesn't really
// start the client.
startRecentsActivityInBackground("preloadRecents");
- targetStack = mDefaultTaskDisplayArea.getStack(WINDOWING_MODE_UNDEFINED,
+ targetStack = mDefaultTaskDisplayArea.getRootTask(WINDOWING_MODE_UNDEFINED,
mTargetActivityType);
targetActivity = getTargetActivity(targetStack);
if (targetActivity == null) {
@@ -165,12 +165,12 @@
Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER, "RecentsAnimation#startRecentsActivity");
// If the activity is associated with the recents stack, then try and get that first
- Task targetStack = mDefaultTaskDisplayArea.getStack(WINDOWING_MODE_UNDEFINED,
+ Task targetStack = mDefaultTaskDisplayArea.getRootTask(WINDOWING_MODE_UNDEFINED,
mTargetActivityType);
ActivityRecord targetActivity = getTargetActivity(targetStack);
final boolean hasExistingActivity = targetActivity != null;
if (hasExistingActivity) {
- mRestoreTargetBehindStack = getStackAbove(targetStack);
+ mRestoreTargetBehindStack = getRootTaskAbove(targetStack);
if (mRestoreTargetBehindStack == null) {
notifyAnimationCancelBeforeStart(recentsAnimationRunner);
ProtoLog.d(WM_DEBUG_RECENTS_ANIMATIONS,
@@ -197,9 +197,9 @@
try {
if (hasExistingActivity) {
// Move the recents activity into place for the animation if it is not top most
- mDefaultTaskDisplayArea.moveStackBehindBottomMostVisibleStack(targetStack);
+ mDefaultTaskDisplayArea.moveRootTaskBehindBottomMostVisibleRootTask(targetStack);
ProtoLog.d(WM_DEBUG_RECENTS_ANIMATIONS, "Moved stack=%s behind stack=%s",
- targetStack, getStackAbove(targetStack));
+ targetStack, getRootTaskAbove(targetStack));
// If there are multiple tasks in the target stack (ie. the home stack, with 3p
// and default launchers coexisting), then move the task to the top as a part of
@@ -213,12 +213,12 @@
startRecentsActivityInBackground("startRecentsActivity_noTargetActivity");
// Move the recents activity into place for the animation
- targetStack = mDefaultTaskDisplayArea.getStack(WINDOWING_MODE_UNDEFINED,
+ targetStack = mDefaultTaskDisplayArea.getRootTask(WINDOWING_MODE_UNDEFINED,
mTargetActivityType);
targetActivity = getTargetActivity(targetStack);
- mDefaultTaskDisplayArea.moveStackBehindBottomMostVisibleStack(targetStack);
+ mDefaultTaskDisplayArea.moveRootTaskBehindBottomMostVisibleRootTask(targetStack);
ProtoLog.d(WM_DEBUG_RECENTS_ANIMATIONS, "Moved stack=%s behind stack=%s",
- targetStack, getStackAbove(targetStack));
+ targetStack, getRootTaskAbove(targetStack));
mWindowManager.prepareAppTransitionNone();
mWindowManager.executeAppTransition();
@@ -257,7 +257,7 @@
START_TASK_TO_FRONT, targetActivity, options);
// Register for stack order changes
- mDefaultTaskDisplayArea.registerStackOrderChangedListener(this);
+ mDefaultTaskDisplayArea.registerRootTaskOrderChangedListener(this);
} catch (Exception e) {
Slog.e(TAG, "Failed to start recents activity", e);
throw e;
@@ -275,7 +275,7 @@
mWindowManager.getRecentsAnimationController(), reorderMode);
// Unregister for stack order changes
- mDefaultTaskDisplayArea.unregisterStackOrderChangedListener(this);
+ mDefaultTaskDisplayArea.unregisterRootTaskOrderChangedListener(this);
final RecentsAnimationController controller =
mWindowManager.getRecentsAnimationController();
@@ -303,7 +303,7 @@
try {
mWindowManager.cleanupRecentsAnimation(reorderMode);
- final Task targetStack = mDefaultTaskDisplayArea.getStack(
+ final Task targetStack = mDefaultTaskDisplayArea.getRootTask(
WINDOWING_MODE_UNDEFINED, mTargetActivityType);
// Prefer to use the original target activity instead of top activity because
// we may have moved another task to top (starting 3p launcher).
@@ -348,10 +348,10 @@
} else if (reorderMode == REORDER_MOVE_TO_ORIGINAL_POSITION){
// Restore the target stack to its previous position
final TaskDisplayArea taskDisplayArea = targetActivity.getDisplayArea();
- taskDisplayArea.moveStackBehindStack(targetStack,
+ taskDisplayArea.moveRootTaskBehindRootTask(targetStack,
mRestoreTargetBehindStack);
if (WM_DEBUG_RECENTS_ANIMATIONS.isLogToAny()) {
- final Task aboveTargetStack = getStackAbove(targetStack);
+ final Task aboveTargetStack = getRootTaskAbove(targetStack);
if (mRestoreTargetBehindStack != null
&& aboveTargetStack != mRestoreTargetBehindStack) {
ProtoLog.w(WM_DEBUG_RECENTS_ANIMATIONS,
@@ -378,7 +378,7 @@
mWindowManager.prepareAppTransitionNone();
mService.mRootWindowContainer.ensureActivitiesVisible(null, 0, false);
- mService.mRootWindowContainer.resumeFocusedStacksTopActivities();
+ mService.mRootWindowContainer.resumeFocusedTasksTopActivities();
// No reason to wait for the pausing activity in this case, as the hiding of
// surfaces needs to be done immediately.
@@ -412,9 +412,9 @@
}
@Override
- public void onStackOrderChanged(Task stack) {
- ProtoLog.d(WM_DEBUG_RECENTS_ANIMATIONS, "onStackOrderChanged(): stack=%s", stack);
- if (mDefaultTaskDisplayArea.getIndexOf(stack) == -1 || !stack.shouldBeVisible(null)) {
+ public void onRootTaskOrderChanged(Task rootTask) {
+ ProtoLog.d(WM_DEBUG_RECENTS_ANIMATIONS, "onStackOrderChanged(): stack=%s", rootTask);
+ if (mDefaultTaskDisplayArea.getIndexOf(rootTask) == -1 || !rootTask.shouldBeVisible(null)) {
// The stack is not visible, so ignore this change
return;
}
@@ -428,8 +428,8 @@
// cases:
// 1) The next launching task is not being animated by the recents animation
// 2) The next task is home activity. (i.e. pressing home key to back home in recents).
- if ((!controller.isAnimatingTask(stack.getTopMostTask())
- || controller.isTargetApp(stack.getTopNonFinishingActivity()))
+ if ((!controller.isAnimatingTask(rootTask.getTopMostTask())
+ || controller.isTargetApp(rootTask.getTopNonFinishingActivity()))
&& controller.shouldDeferCancelUntilNextTransition()) {
// Always prepare an app transition since we rely on the transition callbacks to cleanup
mWindowManager.prepareAppTransitionNone();
@@ -468,8 +468,8 @@
* @return The top stack that is not always-on-top.
*/
private Task getTopNonAlwaysOnTopStack() {
- for (int i = mDefaultTaskDisplayArea.getStackCount() - 1; i >= 0; i--) {
- final Task s = mDefaultTaskDisplayArea.getStackAt(i);
+ for (int i = mDefaultTaskDisplayArea.getRootTaskCount() - 1; i >= 0; i--) {
+ final Task s = mDefaultTaskDisplayArea.getRootTaskAt(i);
if (s.getWindowConfiguration().isAlwaysOnTop()) {
continue;
}
diff --git a/services/core/java/com/android/server/wm/RecentsAnimationController.java b/services/core/java/com/android/server/wm/RecentsAnimationController.java
index abee032..5da668c 100644
--- a/services/core/java/com/android/server/wm/RecentsAnimationController.java
+++ b/services/core/java/com/android/server/wm/RecentsAnimationController.java
@@ -398,7 +398,7 @@
final ArrayList<Task> visibleTasks = mDisplayContent.getDefaultTaskDisplayArea()
.getVisibleTasks();
final Task targetStack = mDisplayContent.getDefaultTaskDisplayArea()
- .getStack(WINDOWING_MODE_UNDEFINED, targetActivityType);
+ .getRootTask(WINDOWING_MODE_UNDEFINED, targetActivityType);
if (targetStack != null) {
final PooledConsumer c = PooledLambda.obtainConsumer((t, outList) ->
{ if (!outList.contains(t)) outList.add(t); }, PooledLambda.__(Task.class),
diff --git a/services/core/java/com/android/server/wm/ResetTargetTaskHelper.java b/services/core/java/com/android/server/wm/ResetTargetTaskHelper.java
index 7bd5d03..17cb890 100644
--- a/services/core/java/com/android/server/wm/ResetTargetTaskHelper.java
+++ b/services/core/java/com/android/server/wm/ResetTargetTaskHelper.java
@@ -237,7 +237,7 @@
while (!mPendingReparentActivities.isEmpty()) {
final ActivityRecord r = mPendingReparentActivities.remove(0);
- final boolean alwaysCreateTask = DisplayContent.alwaysCreateStack(windowingMode,
+ final boolean alwaysCreateTask = DisplayContent.alwaysCreateRootTask(windowingMode,
activityType);
final Task task = alwaysCreateTask
? taskDisplayArea.getBottomMostTask() : mTargetStack.getBottomMostTask();
@@ -251,7 +251,7 @@
}
if (targetTask == null) {
if (alwaysCreateTask) {
- targetTask = taskDisplayArea.getOrCreateStack(windowingMode,
+ targetTask = taskDisplayArea.getOrCreateRootTask(windowingMode,
activityType, false /* onTop */);
} else {
targetTask = mTargetStack.reuseOrCreateTask(r.info, null /*intent*/,
diff --git a/services/core/java/com/android/server/wm/RootWindowContainer.java b/services/core/java/com/android/server/wm/RootWindowContainer.java
index cbeaecf..497087a 100644
--- a/services/core/java/com/android/server/wm/RootWindowContainer.java
+++ b/services/core/java/com/android/server/wm/RootWindowContainer.java
@@ -256,8 +256,8 @@
/** The current user */
int mCurrentUser;
- /** Stack id of the front stack when user switched, indexed by userId. */
- SparseIntArray mUserStackInFront = new SparseIntArray(2);
+ /** Root task id of the front root task when user switched, indexed by userId. */
+ SparseIntArray mUserRootTaskInFront = new SparseIntArray(2);
/**
* A list of tokens that cause the top activity to be put to sleep.
@@ -296,7 +296,7 @@
c.recycle();
} finally {
mTaskSupervisor.endDeferResume();
- resumeFocusedStacksTopActivities();
+ resumeFocusedTasksTopActivities();
}
}
}
@@ -1484,7 +1484,7 @@
boolean fromHomeKey) {
// Fallback to top focused display or default display if the displayId is invalid.
if (displayId == INVALID_DISPLAY) {
- final Task stack = getTopDisplayFocusedStack();
+ final Task stack = getTopDisplayFocusedRootTask();
displayId = stack != null ? stack.getDisplayId() : DEFAULT_DISPLAY;
}
@@ -1510,7 +1510,7 @@
boolean allowInstrumenting, boolean fromHomeKey) {
// Fallback to top focused display area if the provided one is invalid.
if (taskDisplayArea == null) {
- final Task stack = getTopDisplayFocusedStack();
+ final Task stack = getTopDisplayFocusedRootTask();
taskDisplayArea = stack != null ? stack.getDisplayArea()
: getDefaultTaskDisplayArea();
}
@@ -1677,7 +1677,7 @@
// Only resume home activity if isn't finishing.
if (r != null && !r.finishing) {
r.moveFocusableActivityToTop(myReason);
- return resumeFocusedStacksTopActivities(r.getRootTask(), prev, null);
+ return resumeFocusedTasksTopActivities(r.getRootTask(), prev, null);
}
return startHomeOnTaskDisplayArea(mCurrentUser, myReason, taskDisplayArea,
false /* allowInstrumenting */, false /* fromHomeKey */);
@@ -1831,12 +1831,12 @@
*/
List<IBinder> getTopVisibleActivities() {
final ArrayList<IBinder> topActivityTokens = new ArrayList<>();
- final Task topFocusedStack = getTopDisplayFocusedStack();
+ final Task topFocusedStack = getTopDisplayFocusedRootTask();
// Traverse all displays.
forAllTaskDisplayAreas(taskDisplayArea -> {
// Traverse all stacks on a display area.
- for (int sNdx = taskDisplayArea.getStackCount() - 1; sNdx >= 0; --sNdx) {
- final Task stack = taskDisplayArea.getStackAt(sNdx);
+ for (int sNdx = taskDisplayArea.getRootTaskCount() - 1; sNdx >= 0; --sNdx) {
+ final Task stack = taskDisplayArea.getRootTaskAt(sNdx);
// Get top activity from a visible stack and add it to the list.
if (stack.shouldBeVisible(null /* starting */)) {
final ActivityRecord top = stack.getTopNonFinishingActivity();
@@ -1854,9 +1854,9 @@
}
@Nullable
- Task getTopDisplayFocusedStack() {
+ Task getTopDisplayFocusedRootTask() {
for (int i = getChildCount() - 1; i >= 0; --i) {
- final Task focusedStack = getChildAt(i).getFocusedStack();
+ final Task focusedStack = getChildAt(i).getFocusedRootTask();
if (focusedStack != null) {
return focusedStack;
}
@@ -1866,7 +1866,7 @@
@Nullable
ActivityRecord getTopResumedActivity() {
- final Task focusedStack = getTopDisplayFocusedStack();
+ final Task focusedStack = getTopDisplayFocusedRootTask();
if (focusedStack == null) {
return null;
}
@@ -1879,8 +1879,8 @@
return getItemFromTaskDisplayAreas(TaskDisplayArea::getFocusedActivity);
}
- boolean isTopDisplayFocusedStack(Task stack) {
- return stack != null && stack == getTopDisplayFocusedStack();
+ boolean isTopDisplayFocusedRootTask(Task task) {
+ return task != null && task == getTopDisplayFocusedRootTask();
}
void updatePreviousProcess(ActivityRecord r) {
@@ -1891,9 +1891,9 @@
// previous app if this activity is being hosted by the process that is actually still the
// foreground.
WindowProcessController fgApp = reduceOnAllTaskDisplayAreas((taskDisplayArea, app) -> {
- for (int sNdx = taskDisplayArea.getStackCount() - 1; sNdx >= 0; --sNdx) {
- final Task stack = taskDisplayArea.getStackAt(sNdx);
- if (isTopDisplayFocusedStack(stack)) {
+ for (int sNdx = taskDisplayArea.getRootTaskCount() - 1; sNdx >= 0; --sNdx) {
+ final Task stack = taskDisplayArea.getRootTaskAt(sNdx);
+ if (isTopDisplayFocusedRootTask(stack)) {
final ActivityRecord resumedActivity = stack.getResumedActivity();
if (resumedActivity != null) {
app = resumedActivity.app;
@@ -1926,8 +1926,8 @@
return;
}
- for (int taskNdx = displayArea.getStackCount() - 1; taskNdx >= 0; --taskNdx) {
- final Task rootTask = displayArea.getStackAt(taskNdx);
+ for (int taskNdx = displayArea.getRootTaskCount() - 1; taskNdx >= 0; --taskNdx) {
+ final Task rootTask = displayArea.getRootTaskAt(taskNdx);
if (rootTask.getVisibility(null /*starting*/) == TASK_VISIBILITY_INVISIBLE) {
break;
}
@@ -2009,7 +2009,7 @@
}
boolean switchUser(int userId, UserState uss) {
- final Task topFocusedStack = getTopDisplayFocusedStack();
+ final Task topFocusedStack = getTopDisplayFocusedRootTask();
final int focusStackId = topFocusedStack != null
? topFocusedStack.getRootTaskId() : INVALID_TASK_ID;
// We dismiss the docked stack whenever we switch users.
@@ -2021,19 +2021,19 @@
// appropriate.
removeRootTasksInWindowingModes(WINDOWING_MODE_PINNED);
- mUserStackInFront.put(mCurrentUser, focusStackId);
+ mUserRootTaskInFront.put(mCurrentUser, focusStackId);
mCurrentUser = userId;
mTaskSupervisor.mStartingUsers.add(uss);
forAllTaskDisplayAreas(taskDisplayArea -> {
- for (int sNdx = taskDisplayArea.getStackCount() - 1; sNdx >= 0; --sNdx) {
- final Task stack = taskDisplayArea.getStackAt(sNdx);
+ for (int sNdx = taskDisplayArea.getRootTaskCount() - 1; sNdx >= 0; --sNdx) {
+ final Task stack = taskDisplayArea.getRootTaskAt(sNdx);
stack.switchUser(userId);
}
});
- final int restoreStackId = mUserStackInFront.get(userId);
- Task stack = getStack(restoreStackId);
+ final int restoreStackId = mUserRootTaskInFront.get(userId);
+ Task stack = getRootTask(restoreStackId);
if (stack == null) {
stack = getDefaultTaskDisplayArea().getOrCreateRootHomeTask();
}
@@ -2048,20 +2048,20 @@
}
void removeUser(int userId) {
- mUserStackInFront.delete(userId);
+ mUserRootTaskInFront.delete(userId);
}
/**
- * Update the last used stack id for non-current user (current user's last
- * used stack is the focused stack)
+ * Update the last used root task id for non-current user (current user's last
+ * used root task is the focused root task)
*/
- void updateUserStack(int userId, Task stack) {
+ void updateUserRootTask(int userId, Task rootTask) {
if (userId != mCurrentUser) {
- if (stack == null) {
- stack = getDefaultTaskDisplayArea().getOrCreateRootHomeTask();
+ if (rootTask == null) {
+ rootTask = getDefaultTaskDisplayArea().getOrCreateRootHomeTask();
}
- mUserStackInFront.put(userId, stack.getRootTaskId());
+ mUserRootTaskInFront.put(userId, rootTask.getRootTaskId());
}
}
@@ -2072,8 +2072,9 @@
* @param taskDisplayArea The task display area to move stack to.
* @param onTop Indicates whether container should be place on top or on bottom.
*/
- void moveStackToTaskDisplayArea(int stackId, TaskDisplayArea taskDisplayArea, boolean onTop) {
- final Task stack = getStack(stackId);
+ void moveRootTaskToTaskDisplayArea(int stackId, TaskDisplayArea taskDisplayArea,
+ boolean onTop) {
+ final Task stack = getRootTask(stackId);
if (stack == null) {
throw new IllegalArgumentException("moveStackToTaskDisplayArea: Unknown stackId="
+ stackId);
@@ -2101,22 +2102,23 @@
/**
* Move stack with all its existing content to specified display.
*
- * @param stackId Id of stack to move.
+ * @param rootTaskId Id of stack to move.
* @param displayId Id of display to move stack to.
* @param onTop Indicates whether container should be place on top or on bottom.
*/
- void moveStackToDisplay(int stackId, int displayId, boolean onTop) {
+ void moveRootTaskToDisplay(int rootTaskId, int displayId, boolean onTop) {
final DisplayContent displayContent = getDisplayContentOrCreate(displayId);
if (displayContent == null) {
throw new IllegalArgumentException("moveStackToDisplay: Unknown displayId="
+ displayId);
}
- moveStackToTaskDisplayArea(stackId, displayContent.getDefaultTaskDisplayArea(), onTop);
+ moveRootTaskToTaskDisplayArea(rootTaskId, displayContent.getDefaultTaskDisplayArea(),
+ onTop);
}
- boolean moveTopStackActivityToPinnedRootTask(int rootTaskId) {
- final Task rootTask = getStack(rootTaskId);
+ boolean moveTopRootTaskActivityToPinnedRootTask(int rootTaskId) {
+ final Task rootTask = getRootTask(rootTaskId);
if (rootTask == null) {
throw new IllegalArgumentException(
"moveTopStackActivityToPinnedRootTask: Unknown rootTaskId=" + rootTaskId);
@@ -2135,11 +2137,11 @@
return false;
}
- moveActivityToPinnedStack(r, "moveTopStackActivityToPinnedRootTask");
+ moveActivityToPinnedRootTask(r, "moveTopStackActivityToPinnedRootTask");
return true;
}
- void moveActivityToPinnedStack(ActivityRecord r, String reason) {
+ void moveActivityToPinnedRootTask(ActivityRecord r, String reason) {
mService.deferWindowLayout();
final TaskDisplayArea taskDisplayArea = r.getDisplayArea();
@@ -2159,25 +2161,26 @@
r.getDisplayContent().prepareAppTransition(TRANSIT_NONE);
final boolean singleActivity = task.getChildCount() == 1;
- final Task stack;
+ final Task rootTask;
if (singleActivity) {
- stack = task;
+ rootTask = task;
} else {
// In the case of multiple activities, we will create a new task for it and then
// move the PIP activity into the task.
- stack = taskDisplayArea.createStack(WINDOWING_MODE_UNDEFINED, r.getActivityType(),
- ON_TOP, r.info, r.intent, false /* createdByOrganizer */);
+ rootTask = taskDisplayArea.createRootTask(WINDOWING_MODE_UNDEFINED,
+ r.getActivityType(), ON_TOP, r.info, r.intent,
+ false /* createdByOrganizer */);
// It's possible the task entering PIP is in freeform, so save the last
// non-fullscreen bounds. Then when this new PIP task exits PIP, it can restore
// to its previous freeform bounds.
- stack.setLastNonFullscreenBounds(task.mLastNonFullscreenBounds);
- stack.setBounds(task.getBounds());
+ rootTask.setLastNonFullscreenBounds(task.mLastNonFullscreenBounds);
+ rootTask.setBounds(task.getBounds());
// There are multiple activities in the task and moving the top activity should
// reveal/leave the other activities in their original task.
// On the other hand, ActivityRecord#onParentChanged takes care of setting the
// up-to-dated pinned stack information on this newly created stack.
- r.reparent(stack, MAX_VALUE, reason);
+ r.reparent(rootTask, MAX_VALUE, reason);
// In the case of this activity entering PIP due to it being moved to the back,
// the old activity would have a TRANSIT_TASK_TO_BACK transition that needs to be
@@ -2196,17 +2199,17 @@
// The intermediate windowing mode to be set on the ActivityRecord later.
// This needs to happen before the re-parenting, otherwise we will always set the
// ActivityRecord to be fullscreen.
- final int intermediateWindowingMode = stack.getWindowingMode();
- if (stack.getParent() != taskDisplayArea) {
+ final int intermediateWindowingMode = rootTask.getWindowingMode();
+ if (rootTask.getParent() != taskDisplayArea) {
// stack is nested, but pinned tasks need to be direct children of their
// display area, so reparent.
- stack.reparent(taskDisplayArea, true /* onTop */);
+ rootTask.reparent(taskDisplayArea, true /* onTop */);
}
// Defer the windowing mode change until after the transition to prevent the activity
// from doing work and changing the activity visuals while animating
// TODO(task-org): Figure-out more structured way to do this long term.
r.setWindowingMode(intermediateWindowingMode);
- stack.setWindowingMode(WINDOWING_MODE_PINNED);
+ rootTask.setWindowingMode(WINDOWING_MODE_PINNED);
// Reset the state that indicates it can enter PiP while pausing after we've moved it
// to the pinned stack
@@ -2216,7 +2219,7 @@
}
ensureActivitiesVisible(null, 0, false /* preserveWindows */);
- resumeFocusedStacksTopActivities();
+ resumeFocusedTasksTopActivities();
notifyActivityPipModeChanged(r);
}
@@ -2288,13 +2291,13 @@
* @return The task id that was finished in this stack, or INVALID_TASK_ID if none was finished.
*/
int finishTopCrashedActivities(WindowProcessController app, String reason) {
- Task focusedStack = getTopDisplayFocusedStack();
+ Task focusedStack = getTopDisplayFocusedRootTask();
Task finishedTask = reduceOnAllTaskDisplayAreas((taskDisplayArea, task) -> {
// It is possible that request to finish activity might also remove its task and
// stack, so we need to be careful with indexes in the loop and check child count
// every time.
- for (int stackNdx = 0; stackNdx < taskDisplayArea.getStackCount(); ++stackNdx) {
- final Task stack = taskDisplayArea.getStackAt(stackNdx);
+ for (int stackNdx = 0; stackNdx < taskDisplayArea.getRootTaskCount(); ++stackNdx) {
+ final Task stack = taskDisplayArea.getRootTaskAt(stackNdx);
final Task t = stack.finishTopCrashedActivityLocked(app, reason);
if (stack == focusedStack || task == null) {
task = t;
@@ -2305,21 +2308,21 @@
return finishedTask != null ? finishedTask.mTaskId : INVALID_TASK_ID;
}
- boolean resumeFocusedStacksTopActivities() {
- return resumeFocusedStacksTopActivities(null, null, null);
+ boolean resumeFocusedTasksTopActivities() {
+ return resumeFocusedTasksTopActivities(null, null, null);
}
- boolean resumeFocusedStacksTopActivities(
- Task targetStack, ActivityRecord target, ActivityOptions targetOptions) {
+ boolean resumeFocusedTasksTopActivities(
+ Task targetRootTask, ActivityRecord target, ActivityOptions targetOptions) {
if (!mTaskSupervisor.readyToResume()) {
return false;
}
boolean result = false;
- if (targetStack != null && (targetStack.isTopStackInDisplayArea()
- || getTopDisplayFocusedStack() == targetStack)) {
- result = targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
+ if (targetRootTask != null && (targetRootTask.isTopStackInDisplayArea()
+ || getTopDisplayFocusedRootTask() == targetRootTask)) {
+ result = targetRootTask.resumeTopActivityUncheckedLocked(target, targetOptions);
}
for (int displayNdx = getChildCount() - 1; displayNdx >= 0; --displayNdx) {
@@ -2327,13 +2330,13 @@
final boolean curResult = result;
boolean resumedOnDisplay = display.reduceOnAllTaskDisplayAreas(
(taskDisplayArea, resumed) -> {
- for (int sNdx = taskDisplayArea.getStackCount() - 1; sNdx >= 0; --sNdx) {
- final Task stack = taskDisplayArea.getStackAt(sNdx);
- final ActivityRecord topRunningActivity = stack.topRunningActivity();
- if (!stack.isFocusableAndVisible() || topRunningActivity == null) {
+ for (int sNdx = taskDisplayArea.getRootTaskCount() - 1; sNdx >= 0; --sNdx) {
+ final Task rootTask = taskDisplayArea.getRootTaskAt(sNdx);
+ final ActivityRecord topRunningActivity = rootTask.topRunningActivity();
+ if (!rootTask.isFocusableAndVisible() || topRunningActivity == null) {
continue;
}
- if (stack == targetStack) {
+ if (rootTask == targetRootTask) {
// Simply update the result for targetStack because the targetStack
// had already resumed in above. We don't want to resume it again,
// especially in some cases, it would cause a second launch failure
@@ -2341,12 +2344,12 @@
resumed |= curResult;
continue;
}
- if (taskDisplayArea.isTopStack(stack)
+ if (taskDisplayArea.isTopRootTask(rootTask)
&& topRunningActivity.isState(RESUMED)) {
// Kick off any lingering app transitions form the MoveTaskToFront
// operation, but only consider the top task and stack on that
// display.
- stack.executeAppTransition(targetOptions);
+ rootTask.executeAppTransition(targetOptions);
} else {
resumed |= topRunningActivity.makeActiveIfNeeded(target);
}
@@ -2359,10 +2362,10 @@
// crashed) it's possible that nothing was resumed on a display. Requesting resume
// of top activity in focused stack explicitly will make sure that at least home
// activity is started and resumed, and no recursion occurs.
- final Task focusedStack = display.getFocusedStack();
- if (focusedStack != null) {
- result |= focusedStack.resumeTopActivityUncheckedLocked(target, targetOptions);
- } else if (targetStack == null) {
+ final Task focusedRoot = display.getFocusedRootTask();
+ if (focusedRoot != null) {
+ result |= focusedRoot.resumeTopActivityUncheckedLocked(target, targetOptions);
+ } else if (targetRootTask == null) {
result |= resumeHomeActivity(null /* prev */, "no-focusable-task",
display.getDefaultTaskDisplayArea());
}
@@ -2388,8 +2391,8 @@
// Set the sleeping state of the stacks on the display.
display.forAllTaskDisplayAreas(taskDisplayArea -> {
- for (int sNdx = taskDisplayArea.getStackCount() - 1; sNdx >= 0; --sNdx) {
- final Task stack = taskDisplayArea.getStackAt(sNdx);
+ for (int sNdx = taskDisplayArea.getRootTaskCount() - 1; sNdx >= 0; --sNdx) {
+ final Task stack = taskDisplayArea.getRootTaskAt(sNdx);
if (displayShouldSleep) {
stack.goToSleepIfPossible(false /* shuttingDown */);
} else {
@@ -2416,34 +2419,34 @@
}
}
- protected Task getStack(int stackId) {
+ protected Task getRootTask(int rooTaskId) {
for (int i = getChildCount() - 1; i >= 0; --i) {
- final Task stack = getChildAt(i).getStack(stackId);
- if (stack != null) {
- return stack;
+ final Task rootTask = getChildAt(i).getRootTask(rooTaskId);
+ if (rootTask != null) {
+ return rootTask;
}
}
return null;
}
- /** @see DisplayContent#getStack(int, int) */
- Task getStack(int windowingMode, int activityType) {
+ /** @see DisplayContent#getRootTask(int, int) */
+ Task getRootTask(int windowingMode, int activityType) {
for (int i = getChildCount() - 1; i >= 0; --i) {
- final Task stack = getChildAt(i).getStack(windowingMode, activityType);
- if (stack != null) {
- return stack;
+ final Task rootTask = getChildAt(i).getRootTask(windowingMode, activityType);
+ if (rootTask != null) {
+ return rootTask;
}
}
return null;
}
- private Task getStack(int windowingMode, int activityType,
+ private Task getRootTask(int windowingMode, int activityType,
int displayId) {
DisplayContent display = getDisplayContent(displayId);
if (display == null) {
return null;
}
- return display.getStack(windowingMode, activityType);
+ return display.getRootTask(windowingMode, activityType);
}
private RootTaskInfo getRootTaskInfo(Task task) {
@@ -2488,7 +2491,7 @@
}
RootTaskInfo getRootTaskInfo(int taskId) {
- Task task = getStack(taskId);
+ Task task = getRootTask(taskId);
if (task != null) {
return getRootTaskInfo(task);
}
@@ -2496,12 +2499,12 @@
}
RootTaskInfo getRootTaskInfo(int windowingMode, int activityType) {
- final Task stack = getStack(windowingMode, activityType);
+ final Task stack = getRootTask(windowingMode, activityType);
return (stack != null) ? getRootTaskInfo(stack) : null;
}
RootTaskInfo getRootTaskInfo(int windowingMode, int activityType, int displayId) {
- final Task stack = getStack(windowingMode, activityType, displayId);
+ final Task stack = getRootTask(windowingMode, activityType, displayId);
return (stack != null) ? getRootTaskInfo(stack) : null;
}
@@ -2510,8 +2513,8 @@
ArrayList<RootTaskInfo> list = new ArrayList<>();
if (displayId == INVALID_DISPLAY) {
forAllTaskDisplayAreas(taskDisplayArea -> {
- for (int sNdx = taskDisplayArea.getStackCount() - 1; sNdx >= 0; --sNdx) {
- final Task stack = taskDisplayArea.getStackAt(sNdx);
+ for (int sNdx = taskDisplayArea.getRootTaskCount() - 1; sNdx >= 0; --sNdx) {
+ final Task stack = taskDisplayArea.getRootTaskAt(sNdx);
list.add(getRootTaskInfo(stack));
}
});
@@ -2522,8 +2525,8 @@
return list;
}
display.forAllTaskDisplayAreas(taskDisplayArea -> {
- for (int sNdx = taskDisplayArea.getStackCount() - 1; sNdx >= 0; --sNdx) {
- final Task stack = taskDisplayArea.getStackAt(sNdx);
+ for (int sNdx = taskDisplayArea.getRootTaskCount() - 1; sNdx >= 0; --sNdx) {
+ final Task stack = taskDisplayArea.getRootTaskAt(sNdx);
list.add(getRootTaskInfo(stack));
}
});
@@ -2595,16 +2598,16 @@
mDisplayManagerInternal.setDisplayAccessUIDs(mDisplayAccessUIDs);
}
- Task findStackBehind(Task stack) {
- final TaskDisplayArea taskDisplayArea = stack.getDisplayArea();
+ Task findRootTaskBehind(Task rootTask) {
+ final TaskDisplayArea taskDisplayArea = rootTask.getDisplayArea();
if (taskDisplayArea != null) {
- for (int i = taskDisplayArea.getStackCount() - 1; i >= 0; i--) {
- if (taskDisplayArea.getStackAt(i) == stack && i > 0) {
- return taskDisplayArea.getStackAt(i - 1);
+ for (int i = taskDisplayArea.getRootTaskCount() - 1; i >= 0; i--) {
+ if (taskDisplayArea.getRootTaskAt(i) == rootTask && i > 0) {
+ return taskDisplayArea.getRootTaskAt(i - 1);
}
}
}
- throw new IllegalStateException("Failed to find a stack behind stack=" + stack
+ throw new IllegalStateException("Failed to find a root task behind root task =" + rootTask
+ " in=" + taskDisplayArea);
}
@@ -2740,22 +2743,22 @@
r.destroyImmediately(mDestroyAllActivitiesReason);
}
- // Tries to put all activity stacks to sleep. Returns true if all stacks were
+ // Tries to put all activity tasks to sleep. Returns true if all tasks were
// successfully put to sleep.
- boolean putStacksToSleep(boolean allowDelay, boolean shuttingDown) {
+ boolean putTasksToSleep(boolean allowDelay, boolean shuttingDown) {
return reduceOnAllTaskDisplayAreas((taskDisplayArea, result) -> {
- for (int sNdx = taskDisplayArea.getStackCount() - 1; sNdx >= 0; --sNdx) {
+ for (int sNdx = taskDisplayArea.getRootTaskCount() - 1; sNdx >= 0; --sNdx) {
// Stacks and activities could be removed while putting activities to sleep if
// the app process was gone. This prevents us getting exception by accessing an
// invalid stack index.
- if (sNdx >= taskDisplayArea.getStackCount()) {
+ if (sNdx >= taskDisplayArea.getRootTaskCount()) {
continue;
}
- final Task stack = taskDisplayArea.getStackAt(sNdx);
+ final Task task = taskDisplayArea.getRootTaskAt(sNdx);
if (allowDelay) {
- result &= stack.goToSleepIfPossible(shuttingDown);
+ result &= task.goToSleepIfPossible(shuttingDown);
} else {
- stack.ensureActivitiesVisible(null /* starting */, 0 /* configChanges */,
+ task.ensureActivitiesVisible(null /* starting */, 0 /* configChanges */,
!PRESERVE_WINDOWS);
}
}
@@ -2824,9 +2827,9 @@
return false;
}
- Task getLaunchStack(@Nullable ActivityRecord r,
+ Task getLaunchRootTask(@Nullable ActivityRecord r,
@Nullable ActivityOptions options, @Nullable Task candidateTask, boolean onTop) {
- return getLaunchStack(r, options, candidateTask, onTop, null /* launchParams */,
+ return getLaunchRootTask(r, options, candidateTask, onTop, null /* launchParams */,
-1 /* no realCallingPid */, -1 /* no realCallingUid */);
}
@@ -2841,7 +2844,7 @@
* @param realCallingUid The uid from {@link ActivityStarter#setRealCallingUid}
* @return The stack to use for the launch or INVALID_STACK_ID.
*/
- Task getLaunchStack(@Nullable ActivityRecord r,
+ Task getLaunchRootTask(@Nullable ActivityRecord r,
@Nullable ActivityOptions options, @Nullable Task candidateTask, boolean onTop,
@Nullable LaunchParamsController.LaunchParams launchParams, int realCallingPid,
int realCallingUid) {
@@ -2894,7 +2897,7 @@
realCallingPid, realCallingUid, r.info);
if (canLaunchOnDisplayFromStartRequest || canLaunchOnDisplay(r, tdaDisplayId)) {
if (r != null) {
- final Task result = getValidLaunchStackInTaskDisplayArea(
+ final Task result = getValidLaunchRootTaskInTaskDisplayArea(
taskDisplayArea, r, candidateTask, options, launchParams);
if (result != null) {
return result;
@@ -2902,7 +2905,7 @@
}
// Falling back to default task container
taskDisplayArea = taskDisplayArea.mDisplayContent.getDefaultTaskDisplayArea();
- stack = taskDisplayArea.getOrCreateStack(r, options, candidateTask, activityType,
+ stack = taskDisplayArea.getOrCreateRootTask(r, options, candidateTask, activityType,
onTop);
if (stack != null) {
return stack;
@@ -2956,7 +2959,7 @@
}
}
- return container.getOrCreateStack(r, options, candidateTask, activityType, onTop);
+ return container.getOrCreateRootTask(r, options, candidateTask, activityType, onTop);
}
/** @return true if activity record is null or can be launched on provided display. */
@@ -2977,7 +2980,7 @@
* @return Existing stack if there is a valid one, new dynamic stack if it is valid or null.
*/
@VisibleForTesting
- Task getValidLaunchStackInTaskDisplayArea(@NonNull TaskDisplayArea taskDisplayArea,
+ Task getValidLaunchRootTaskInTaskDisplayArea(@NonNull TaskDisplayArea taskDisplayArea,
@NonNull ActivityRecord r, @Nullable Task candidateTask,
@Nullable ActivityOptions options,
@Nullable LaunchParamsController.LaunchParams launchParams) {
@@ -3016,9 +3019,9 @@
r.getActivityType());
// Return the topmost valid stack on the display.
- for (int i = taskDisplayArea.getStackCount() - 1; i >= 0; --i) {
- final Task stack = taskDisplayArea.getStackAt(i);
- if (isValidLaunchStack(stack, r, windowingMode)) {
+ for (int i = taskDisplayArea.getRootTaskCount() - 1; i >= 0; --i) {
+ final Task stack = taskDisplayArea.getRootTaskAt(i);
+ if (isValidLaunchRootTask(stack, r, windowingMode)) {
return stack;
}
}
@@ -3030,15 +3033,15 @@
final int activityType =
options != null && options.getLaunchActivityType() != ACTIVITY_TYPE_UNDEFINED
? options.getLaunchActivityType() : r.getActivityType();
- return taskDisplayArea.createStack(windowingMode, activityType, true /*onTop*/);
+ return taskDisplayArea.createRootTask(windowingMode, activityType, true /*onTop*/);
}
return null;
}
// TODO: Can probably be consolidated into getLaunchStack()...
- private boolean isValidLaunchStack(Task stack, ActivityRecord r, int windowingMode) {
- switch (stack.getActivityType()) {
+ private boolean isValidLaunchRootTask(Task task, ActivityRecord r, int windowingMode) {
+ switch (task.getActivityType()) {
case ACTIVITY_TYPE_HOME:
return r.isActivityTypeHome();
case ACTIVITY_TYPE_RECENTS:
@@ -3048,13 +3051,13 @@
case ACTIVITY_TYPE_DREAM:
return r.isActivityTypeDream();
}
- if (stack.mCreatedByOrganizer) {
+ if (task.mCreatedByOrganizer) {
// Don't launch directly into task created by organizer...but why can't we?
return false;
}
// There is a 1-to-1 relationship between stack and task when not in
// primary split-windowing mode.
- if (stack.getWindowingMode() == WINDOWING_MODE_SPLIT_SCREEN_PRIMARY
+ if (task.getWindowingMode() == WINDOWING_MODE_SPLIT_SCREEN_PRIMARY
&& r.supportsSplitScreenWindowingMode()
&& (windowingMode == WINDOWING_MODE_SPLIT_SCREEN_PRIMARY
|| windowingMode == WINDOWING_MODE_UNDEFINED)) {
@@ -3091,8 +3094,7 @@
* candidate.
* @return Next focusable {@link Task}, {@code null} if not found.
*/
- Task getNextFocusableStack(@NonNull Task currentFocus,
- boolean ignoreCurrent) {
+ Task getNextFocusableRootTask(@NonNull Task currentFocus, boolean ignoreCurrent) {
// First look for next focusable stack on the same display
TaskDisplayArea preferredDisplayArea = currentFocus.getDisplayArea();
if (preferredDisplayArea == null) {
@@ -3101,7 +3103,7 @@
preferredDisplayArea = getDisplayContent(currentFocus.mPrevDisplayId)
.getDefaultTaskDisplayArea();
}
- final Task preferredFocusableStack = preferredDisplayArea.getNextFocusableStack(
+ final Task preferredFocusableStack = preferredDisplayArea.getNextFocusableRootTask(
currentFocus, ignoreCurrent);
if (preferredFocusableStack != null) {
return preferredFocusableStack;
@@ -3121,7 +3123,7 @@
continue;
}
final Task nextFocusableStack = display.getDefaultTaskDisplayArea()
- .getNextFocusableStack(currentFocus, ignoreCurrent);
+ .getNextFocusableRootTask(currentFocus, ignoreCurrent);
if (nextFocusableStack != null) {
return nextFocusableStack;
}
@@ -3257,9 +3259,9 @@
void finishVoiceTask(IVoiceInteractionSession session) {
forAllTaskDisplayAreas(taskDisplayArea -> {
- final int numStacks = taskDisplayArea.getStackCount();
+ final int numStacks = taskDisplayArea.getRootTaskCount();
for (int stackNdx = 0; stackNdx < numStacks; ++stackNdx) {
- final Task stack = taskDisplayArea.getStackAt(stackNdx);
+ final Task stack = taskDisplayArea.getRootTaskAt(stackNdx);
stack.finishVoiceTask(session);
}
});
@@ -3302,7 +3304,7 @@
// If the focused stack is not null or not empty, there should have some activities
// resuming or resumed. Make sure these activities are idle.
- final Task stack = display.getFocusedStack();
+ final Task stack = display.getFocusedRootTask();
if (stack == null || !stack.hasActivity()) {
continue;
}
@@ -3322,8 +3324,8 @@
boolean[] foundResumed = {false};
final boolean foundInvisibleResumedActivity = forAllTaskDisplayAreas(
taskDisplayArea -> {
- for (int sNdx = taskDisplayArea.getStackCount() - 1; sNdx >= 0; --sNdx) {
- final Task stack = taskDisplayArea.getStackAt(sNdx);
+ for (int sNdx = taskDisplayArea.getRootTaskCount() - 1; sNdx >= 0; --sNdx) {
+ final Task stack = taskDisplayArea.getRootTaskAt(sNdx);
final ActivityRecord r = stack.getResumedActivity();
if (r != null) {
if (!r.nowVisible) {
@@ -3344,8 +3346,8 @@
boolean[] pausing = {true};
final boolean hasActivityNotCompleted = forAllTaskDisplayAreas(
taskDisplayArea -> {
- for (int sNdx = taskDisplayArea.getStackCount() - 1; sNdx >= 0; --sNdx) {
- final Task stack = taskDisplayArea.getStackAt(sNdx);
+ for (int sNdx = taskDisplayArea.getRootTaskCount() - 1; sNdx >= 0; --sNdx) {
+ final Task stack = taskDisplayArea.getRootTaskAt(sNdx);
final ActivityRecord r = stack.mPausingActivity;
if (r != null && !r.isState(PAUSED, STOPPED, STOPPING, FINISHING)) {
ProtoLog.d(WM_DEBUG_STATES, "allPausedActivitiesComplete: "
@@ -3410,10 +3412,10 @@
void cancelInitializingActivities() {
forAllTaskDisplayAreas(taskDisplayArea -> {
- for (int sNdx = taskDisplayArea.getStackCount() - 1; sNdx >= 0; --sNdx) {
+ for (int sNdx = taskDisplayArea.getRootTaskCount() - 1; sNdx >= 0; --sNdx) {
// We don't want to clear starting window for activities that aren't occluded
// as we need to display their starting window until they are done initializing.
- taskDisplayArea.getStackAt(sNdx).forAllOccludedActivities(
+ taskDisplayArea.getRootTaskAt(sNdx).forAllOccludedActivities(
ActivityRecord::cancelInitializing);
}
});
@@ -3453,7 +3455,7 @@
// Resolve the stack the task should be placed in now based on options
// and reparent if needed.
final Task launchStack =
- getLaunchStack(null, aOptions, task, onTop);
+ getLaunchRootTask(null, aOptions, task, onTop);
if (launchStack != null && task.getRootTask() != launchStack) {
final int reparentMode = onTop
? REPARENT_MOVE_ROOT_TASK_TO_FRONT : REPARENT_LEAVE_ROOT_TASK_IN_PLACE;
@@ -3498,7 +3500,7 @@
return task;
}
- ActivityRecord isInAnyStack(IBinder token) {
+ ActivityRecord isInAnyTask(IBinder token) {
final ActivityRecord r = ActivityRecord.forTokenLocked(token);
return (r != null && r.isDescendantOf(this)) ? r : null;
}
@@ -3568,7 +3570,7 @@
ArrayList<ActivityRecord> getDumpActivities(String name, boolean dumpVisibleStacksOnly,
boolean dumpFocusedStackOnly) {
if (dumpFocusedStackOnly) {
- final Task topFocusedStack = getTopDisplayFocusedStack();
+ final Task topFocusedStack = getTopDisplayFocusedRootTask();
if (topFocusedStack != null) {
return topFocusedStack.getDumpActivitiesLocked(name);
} else {
@@ -3577,8 +3579,8 @@
} else {
ArrayList<ActivityRecord> activities = new ArrayList<>();
forAllTaskDisplayAreas(taskDisplayArea -> {
- for (int sNdx = taskDisplayArea.getStackCount() - 1; sNdx >= 0; --sNdx) {
- final Task stack = taskDisplayArea.getStackAt(sNdx);
+ for (int sNdx = taskDisplayArea.getRootTaskCount() - 1; sNdx >= 0; --sNdx) {
+ final Task stack = taskDisplayArea.getRootTaskAt(sNdx);
if (!dumpVisibleStacksOnly || stack.shouldBeVisible(null)) {
activities.addAll(stack.getDumpActivitiesLocked(name));
}
@@ -3592,7 +3594,7 @@
public void dump(PrintWriter pw, String prefix, boolean dumpAll) {
super.dump(pw, prefix, dumpAll);
pw.print(prefix);
- pw.println("topDisplayFocusedStack=" + getTopDisplayFocusedStack());
+ pw.println("topDisplayFocusedStack=" + getTopDisplayFocusedRootTask());
for (int i = getChildCount() - 1; i >= 0; --i) {
final DisplayContent display = getChildAt(i);
display.dump(pw, prefix, dumpAll);
@@ -3632,8 +3634,8 @@
pw.print(displayContent.mDisplayId);
pw.println(" (activities from top to bottom):");
displayContent.forAllTaskDisplayAreas(taskDisplayArea -> {
- for (int sNdx = taskDisplayArea.getStackCount() - 1; sNdx >= 0; --sNdx) {
- final Task stack = taskDisplayArea.getStackAt(sNdx);
+ for (int sNdx = taskDisplayArea.getRootTaskCount() - 1; sNdx >= 0; --sNdx) {
+ final Task stack = taskDisplayArea.getRootTaskAt(sNdx);
if (needSep[0]) {
pw.println();
}
diff --git a/services/core/java/com/android/server/wm/RunningTasks.java b/services/core/java/com/android/server/wm/RunningTasks.java
index 7b5b0ad..6ef5d4d 100644
--- a/services/core/java/com/android/server/wm/RunningTasks.java
+++ b/services/core/java/com/android/server/wm/RunningTasks.java
@@ -67,7 +67,7 @@
mProfileIds = profileIds;
mAllowed = allowed;
mFilterOnlyVisibleRecents = filterOnlyVisibleRecents;
- mTopDisplayFocusStack = root.getTopDisplayFocusedStack();
+ mTopDisplayFocusStack = root.getTopDisplayFocusedRootTask();
mRecentTasks = root.mService.getRecentTasks();
final PooledConsumer c = PooledLambda.obtainConsumer(RunningTasks::processTask, this,
diff --git a/services/core/java/com/android/server/wm/Task.java b/services/core/java/com/android/server/wm/Task.java
index fb441fa..4b65ce0f 100644
--- a/services/core/java/com/android/server/wm/Task.java
+++ b/services/core/java/com/android/server/wm/Task.java
@@ -101,7 +101,7 @@
import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_VISIBILITY;
import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_ATM;
import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_WITH_CLASS_NAME;
-import static com.android.server.wm.ActivityTaskManagerService.H.FIRST_ACTIVITY_STACK_MSG;
+import static com.android.server.wm.ActivityTaskManagerService.H.FIRST_ACTIVITY_TASK_MSG;
import static com.android.server.wm.ActivityTaskSupervisor.DEFER_RESUME;
import static com.android.server.wm.ActivityTaskSupervisor.ON_TOP;
import static com.android.server.wm.ActivityTaskSupervisor.PRESERVE_WINDOWS;
@@ -599,7 +599,7 @@
private final AnimatingActivityRegistry mAnimatingActivityRegistry =
new AnimatingActivityRegistry();
- private static final int TRANSLUCENT_TIMEOUT_MSG = FIRST_ACTIVITY_STACK_MSG + 1;
+ private static final int TRANSLUCENT_TIMEOUT_MSG = FIRST_ACTIVITY_TASK_MSG + 1;
private final Handler mHandler;
@@ -652,7 +652,7 @@
if (mUpdateConfig) {
// Ensure the resumed state of the focus activity if we updated the configuration of
// any activity.
- mRootWindowContainer.resumeFocusedStacksTopActivities();
+ mRootWindowContainer.resumeFocusedTasksTopActivities();
}
}
@@ -975,7 +975,7 @@
}
mResizeMode = resizeMode;
mRootWindowContainer.ensureActivitiesVisible(null, 0, !PRESERVE_WINDOWS);
- mRootWindowContainer.resumeFocusedStacksTopActivities();
+ mRootWindowContainer.resumeFocusedTasksTopActivities();
updateTaskDescription();
}
@@ -1030,7 +1030,7 @@
// activities stay the same.
mRootWindowContainer.ensureActivitiesVisible(r, 0, preserveWindow);
if (!kept) {
- mRootWindowContainer.resumeFocusedStacksTopActivities();
+ mRootWindowContainer.resumeFocusedTasksTopActivities();
}
}
}
@@ -1098,7 +1098,7 @@
final RootWindowContainer root = mRootWindowContainer;
final WindowManagerService windowManager = mAtmService.mWindowManager;
final Task sourceStack = getRootTask();
- final Task toStack = supervisor.getReparentTargetStack(this, preferredStack,
+ final Task toStack = supervisor.getReparentTargetRootTask(this, preferredStack,
position == MAX_VALUE);
if (toStack == sourceStack) {
return false;
@@ -1136,7 +1136,7 @@
boolean kept = true;
try {
final ActivityRecord r = topRunningActivityLocked();
- final boolean wasFocused = r != null && root.isTopDisplayFocusedStack(sourceStack)
+ final boolean wasFocused = r != null && root.isTopDisplayFocusedRootTask(sourceStack)
&& (topRunningActivityLocked() == r);
final boolean wasResumed = r != null && sourceStack.getResumedActivity() == r;
final boolean wasPaused = r != null && sourceStack.mPausingActivity == r;
@@ -1176,7 +1176,7 @@
&& moveStackMode == REPARENT_KEEP_ROOT_TASK_AT_FRONT) {
// Move recents to front so it is not behind home stack when going into docked
// mode
- mTaskSupervisor.moveRecentsStackToFront(reason);
+ mTaskSupervisor.moveRecentsRootTaskToFront(reason);
}
} finally {
mAtmService.continueWindowLayout();
@@ -1193,7 +1193,7 @@
// The task might have already been running and its visibility needs to be synchronized
// with the visibility of the stack / windows.
root.ensureActivitiesVisible(null, 0, !mightReplaceWindow);
- root.resumeFocusedStacksTopActivities();
+ root.resumeFocusedTasksTopActivities();
}
// TODO: Handle incorrect request to move before the actual move, not after.
@@ -1696,7 +1696,7 @@
// A rootable task that is now being added to be the child of an organized task. Making
// sure the stack references is keep updated.
if (mTaskOrganizer != null && mCreatedByOrganizer && child.asTask() != null) {
- getDisplayArea().addStackReferenceIfNeeded((Task) child);
+ getDisplayArea().addRootTaskReferenceIfNeeded((Task) child);
}
// Make sure the list of display UID allowlists is updated
@@ -1746,7 +1746,7 @@
// A rootable child task that is now being removed from an organized task. Making sure
// the stack references is keep updated.
if (mCreatedByOrganizer && r.asTask() != null) {
- getDisplayArea().removeStackReferenceIfNeeded((Task) r);
+ getDisplayArea().removeRootTaskReferenceIfNeeded((Task) r);
}
if (!mChildren.contains(r)) {
Slog.e(TAG, "removeChild: r=" + r + " not found in t=" + this);
@@ -2303,7 +2303,7 @@
}
if (prevWindowingMode != getWindowingMode()) {
- taskDisplayArea.onStackWindowingModeChanged(this);
+ taskDisplayArea.onRootTaskWindowingModeChanged(this);
}
if (mDisplayContent == null) {
@@ -2330,7 +2330,7 @@
}
if (windowingModeChanged) {
- taskDisplayArea.onStackWindowingModeChanged(this);
+ taskDisplayArea.onRootTaskWindowingModeChanged(this);
}
if (hasNewOverrideBounds) {
if (inSplitScreenWindowingMode()) {
@@ -3097,7 +3097,7 @@
boolean moveDisplayToTop) {
Task focusableTask = getNextFocusableTask(allowFocusSelf);
if (focusableTask == null) {
- focusableTask = mRootWindowContainer.getNextFocusableStack(this, !allowFocusSelf);
+ focusableTask = mRootWindowContainer.getNextFocusableRootTask(this, !allowFocusSelf);
}
if (focusableTask == null) {
return null;
@@ -5133,7 +5133,7 @@
// The change in force-hidden state will change visibility without triggering a stack
// order change, so we should reset the preferred top focusable stack to ensure it's not
// used if a new activity is started from this task.
- getDisplayArea().resetPreferredTopFocusableStackIfBelow(this);
+ getDisplayArea().resetPreferredTopFocusableRootTaskIfBelow(this);
}
return true;
}
@@ -5276,14 +5276,14 @@
}
mRootWindowContainer.ensureActivitiesVisible(null, 0, PRESERVE_WINDOWS);
- mRootWindowContainer.resumeFocusedStacksTopActivities();
+ mRootWindowContainer.resumeFocusedTasksTopActivities();
}
/** Resume next focusable stack after reparenting to another display. */
void postReparent() {
adjustFocusToNextFocusableTask("reparent", true /* allowFocusSelf */,
true /* moveDisplayToTop */);
- mRootWindowContainer.resumeFocusedStacksTopActivities();
+ mRootWindowContainer.resumeFocusedTasksTopActivities();
// Update visibility of activities before notifying WM. This way it won't try to resize
// windows that are no longer visible.
mRootWindowContainer.ensureActivitiesVisible(null /* starting */, 0 /* configChanges */,
@@ -5320,7 +5320,7 @@
// cutting between them.
// TODO(b/70677280): This is a workaround until we can fix as part of b/70677280.
final Task topFullScreenStack =
- taskDisplayArea.getTopStackInWindowingMode(WINDOWING_MODE_FULLSCREEN);
+ taskDisplayArea.getTopRootTaskInWindowingMode(WINDOWING_MODE_FULLSCREEN);
if (topFullScreenStack != null) {
final Task primarySplitScreenStack =
taskDisplayArea.getRootSplitScreenPrimaryTask();
@@ -5335,10 +5335,10 @@
if (!isActivityTypeHome() && returnsToHomeStack()) {
// Make sure the home stack is behind this stack since that is where we should return to
// when this stack is no longer visible.
- taskDisplayArea.moveHomeStackToFront(reason + " returnToHome");
+ taskDisplayArea.moveHomeRootTaskToFront(reason + " returnToHome");
}
- final Task lastFocusedTask = isRootTask() ? taskDisplayArea.getFocusedStack() : null;
+ final Task lastFocusedTask = isRootTask() ? taskDisplayArea.getFocusedRootTask() : null;
if (task == null) {
task = this;
}
@@ -5366,7 +5366,7 @@
if (parentTask != null) {
parentTask.moveToBack(reason, this);
} else {
- final Task lastFocusedTask = displayArea.getFocusedStack();
+ final Task lastFocusedTask = displayArea.getFocusedRootTask();
displayArea.positionChildAt(POSITION_BOTTOM, this, false /*includingParents*/);
displayArea.updateLastFocusedRootTask(lastFocusedTask, reason);
}
@@ -5515,7 +5515,7 @@
if (prev == null) {
if (resuming == null) {
Slog.wtf(TAG, "Trying to pause when nothing is resumed");
- mRootWindowContainer.resumeFocusedStacksTopActivities();
+ mRootWindowContainer.resumeFocusedTasksTopActivities();
}
return false;
}
@@ -5622,7 +5622,7 @@
// pause, so just treat it as being paused now.
ProtoLog.v(WM_DEBUG_STATES, "Activity not running, resuming next.");
if (resuming == null) {
- mRootWindowContainer.resumeFocusedStacksTopActivities();
+ mRootWindowContainer.resumeFocusedTasksTopActivities();
}
return false;
}
@@ -5675,9 +5675,9 @@
}
if (resumeNext) {
- final Task topStack = mRootWindowContainer.getTopDisplayFocusedStack();
+ final Task topStack = mRootWindowContainer.getTopDisplayFocusedRootTask();
if (topStack != null && !topStack.shouldSleepOrShutDownActivities()) {
- mRootWindowContainer.resumeFocusedStacksTopActivities(topStack, prev, null);
+ mRootWindowContainer.resumeFocusedTasksTopActivities(topStack, prev, null);
} else {
checkReadyForSleep();
final ActivityRecord top = topStack != null ? topStack.topRunningActivity() : null;
@@ -5686,7 +5686,7 @@
// something. Also if the top activity on the stack is not the just paused
// activity, we need to go ahead and resume it to ensure we complete an
// in-flight app switch.
- mRootWindowContainer.resumeFocusedStacksTopActivities();
+ mRootWindowContainer.resumeFocusedTasksTopActivities();
}
}
}
@@ -5709,7 +5709,7 @@
boolean isTopStackInDisplayArea() {
final TaskDisplayArea taskDisplayArea = getDisplayArea();
- return taskDisplayArea != null && taskDisplayArea.isTopStack(this);
+ return taskDisplayArea != null && taskDisplayArea.isTopRootTask(this);
}
/**
@@ -5717,7 +5717,7 @@
* otherwise.
*/
boolean isFocusedStackOnDisplay() {
- return mDisplayContent != null && this == mDisplayContent.getFocusedStack();
+ return mDisplayContent != null && this == mDisplayContent.getFocusedRootTask();
}
/**
@@ -5795,7 +5795,7 @@
*/
boolean isTopSplitScreenStack() {
return inSplitScreenWindowingMode()
- && this == getDisplayArea().getTopStackInWindowingMode(getWindowingMode());
+ && this == getDisplayArea().getTopRootTaskInWindowingMode(getWindowingMode());
}
void checkTranslucentActivityWaiting(ActivityRecord top) {
@@ -5879,7 +5879,7 @@
*
* NOTE: It is not safe to call this method directly as it can cause an activity in a
* non-focused stack to be resumed.
- * Use {@link RootWindowContainer#resumeFocusedStacksTopActivities} to resume the
+ * Use {@link RootWindowContainer#resumeFocusedTasksTopActivities} to resume the
* right activity for the current system state.
*/
@GuardedBy("mService")
@@ -6033,7 +6033,7 @@
mTaskSupervisor.setLaunchSource(next.info.applicationInfo.uid);
ActivityRecord lastResumed = null;
- final Task lastFocusedStack = taskDisplayArea.getLastFocusedStack();
+ final Task lastFocusedStack = taskDisplayArea.getLastFocusedRootTask();
if (lastFocusedStack != null && lastFocusedStack != this) {
// So, why aren't we using prev here??? See the param comment on the method. prev
// doesn't represent the last resumed activity. However, the last focus stack does if
@@ -6048,7 +6048,7 @@
}
}
- boolean pausing = taskDisplayArea.pauseBackStacks(userLeaving, next);
+ boolean pausing = taskDisplayArea.pauseBackTasks(userLeaving, next);
if (mResumedActivity != null) {
ProtoLog.d(WM_DEBUG_STATES, "resumeTopActivityLocked: Pausing %s", mResumedActivity);
pausing |= startPausingLocked(userLeaving, false /* uiSleeping */, next,
@@ -6069,7 +6069,7 @@
// Since the start-process is asynchronous, if we already know the process of next
// activity isn't running, we can start the process earlier to save the time to wait
// for the current activity to be paused.
- final boolean isTop = this == taskDisplayArea.getFocusedStack();
+ final boolean isTop = this == taskDisplayArea.getFocusedRootTask();
mAtmService.startProcessAsync(next, false /* knownToBeDead */, isTop,
isTop ? "pre-top-activity" : "pre-activity");
}
@@ -6359,7 +6359,7 @@
// Try to move focus to the next visible stack with a running activity if this
// stack is not covering the entire screen or is on a secondary display with no home
// stack.
- return mRootWindowContainer.resumeFocusedStacksTopActivities(nextFocusedStack,
+ return mRootWindowContainer.resumeFocusedTasksTopActivities(nextFocusedStack,
prev, null /* targetOptions */);
}
}
@@ -6839,7 +6839,7 @@
AppTimeTracker timeTracker, boolean deferResume, String reason) {
if (DEBUG_SWITCH) Slog.v(TAG_SWITCH, "moveTaskToFront: " + tr);
- final Task topStack = getDisplayArea().getTopStack();
+ final Task topStack = getDisplayArea().getTopRootTask();
final ActivityRecord topActivity = topStack != null
? topStack.getTopNonFinishingActivity() : null;
@@ -6902,7 +6902,7 @@
}
if (!deferResume) {
- mRootWindowContainer.resumeFocusedStacksTopActivities();
+ mRootWindowContainer.resumeFocusedTasksTopActivities();
}
} finally {
mDisplayContent.continueUpdateImeTarget();
@@ -6975,7 +6975,7 @@
// resumed in this case, so we need to execute it explicitly.
mDisplayContent.executeAppTransition();
} else {
- mRootWindowContainer.resumeFocusedStacksTopActivities();
+ mRootWindowContainer.resumeFocusedTasksTopActivities();
}
return true;
}
@@ -7280,7 +7280,7 @@
final boolean wasResumed = topRunningActivity == task.getRootTask().mResumedActivity;
boolean toTop = position >= getChildCount();
- boolean includingParents = toTop || getDisplayArea().getNextFocusableStack(this,
+ boolean includingParents = toTop || getDisplayArea().getNextFocusableRootTask(this,
true /* ignoreCurrent */) == null;
if (WindowManagerDebugConfig.DEBUG_ROOT_TASK) {
Slog.i(TAG_WM, "positionChildAt: positioning task=" + task + " at " + position);
@@ -7309,7 +7309,7 @@
// The task might have already been running and its visibility needs to be synchronized with
// the visibility of the stack / windows.
ensureActivitiesVisible(null, 0, !PRESERVE_WINDOWS);
- mRootWindowContainer.resumeFocusedStacksTopActivities();
+ mRootWindowContainer.resumeFocusedTasksTopActivities();
}
public void setAlwaysOnTop(boolean alwaysOnTop) {
@@ -7431,7 +7431,7 @@
// If there are other focusable stacks on the display, the z-order of the display should not
// be changed just because a task was placed at the bottom. E.g. if it is moving the topmost
// task to bottom, the next focusable stack on the same display should be focused.
- final Task nextFocusableStack = getDisplayArea().getNextFocusableStack(
+ final Task nextFocusableStack = getDisplayArea().getNextFocusableRootTask(
child.getRootTask(), true /* ignoreCurrent */);
positionChildAtBottom(child, nextFocusableStack == null /* includingParents */);
}
diff --git a/services/core/java/com/android/server/wm/TaskChangeNotificationController.java b/services/core/java/com/android/server/wm/TaskChangeNotificationController.java
index 4682ba8..b4d069c 100644
--- a/services/core/java/com/android/server/wm/TaskChangeNotificationController.java
+++ b/services/core/java/com/android/server/wm/TaskChangeNotificationController.java
@@ -193,7 +193,7 @@
switch (msg.what) {
case LOG_STACK_STATE_MSG: {
synchronized (mServiceLock) {
- mTaskSupervisor.logStackState();
+ mTaskSupervisor.logRootTaskState();
}
break;
}
diff --git a/services/core/java/com/android/server/wm/TaskDisplayArea.java b/services/core/java/com/android/server/wm/TaskDisplayArea.java
index 81b8200..4498a8c 100644
--- a/services/core/java/com/android/server/wm/TaskDisplayArea.java
+++ b/services/core/java/com/android/server/wm/TaskDisplayArea.java
@@ -38,7 +38,7 @@
import static com.android.internal.protolog.ProtoLogGroup.WM_DEBUG_STATES;
import static com.android.internal.protolog.ProtoLogGroup.WM_DEBUG_TASKS;
import static com.android.server.wm.ActivityTaskManagerService.TAG_ROOT_TASK;
-import static com.android.server.wm.DisplayContent.alwaysCreateStack;
+import static com.android.server.wm.DisplayContent.alwaysCreateRootTask;
import static com.android.server.wm.Task.ActivityState.RESUMED;
import static com.android.server.wm.Task.TASK_VISIBILITY_VISIBLE;
import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_ROOT_TASK;
@@ -107,9 +107,9 @@
// TODO(b/159029784): Remove when getStack() behavior is cleaned-up
private Task mRootRecentsTask;
- private final ArrayList<Task> mTmpAlwaysOnTopStacks = new ArrayList<>();
- private final ArrayList<Task> mTmpNormalStacks = new ArrayList<>();
- private final ArrayList<Task> mTmpHomeStacks = new ArrayList<>();
+ private final ArrayList<Task> mTmpAlwaysOnTopRootTasks = new ArrayList<>();
+ private final ArrayList<Task> mTmpNormalRootTasks = new ArrayList<>();
+ private final ArrayList<Task> mTmpHomeRootTasks = new ArrayList<>();
private final IntArray mTmpNeedsZBoostIndexes = new IntArray();
private int mTmpLayerForSplitScreenDividerAnchor;
private int mTmpLayerForAnimationLayer;
@@ -128,23 +128,25 @@
* have the topmost index, it is used as a preferred candidate to prevent being unable to resume
* target stack properly when there are other focusable always-on-top stacks.
*/
- Task mPreferredTopFocusableStack;
+ Task mPreferredTopFocusableRootTask;
private final RootWindowContainer.FindTaskResult
mTmpFindTaskResult = new RootWindowContainer.FindTaskResult();
/**
- * If this is the same as {@link #getFocusedStack} then the activity on the top of the focused
- * stack has been resumed. If stacks are changing position this will hold the old stack until
- * the new stack becomes resumed after which it will be set to current focused stack.
+ * If this is the same as {@link #getFocusedRootTask} then the activity on the top of the
+ * focused root task has been resumed. If root tasks are changing position this will hold the
+ * old root task until the new root task becomes resumed after which it will be set to
+ * current focused root task.
*/
- Task mLastFocusedStack;
+ Task mLastFocusedRootTask;
/**
* All of the stacks on this display. Order matters, topmost stack is in front of all other
* stacks, bottommost behind. Accessed directly by ActivityManager package classes. Any calls
- * changing the list should also call {@link #onStackOrderChanged()}.
+ * changing the list should also call {@link #onRootTaskOrderChanged(Task)}.
*/
- private ArrayList<OnStackOrderChangedListener> mStackOrderChangedCallbacks = new ArrayList<>();
+ private ArrayList<OnRootTaskOrderChangedListener> mRootTaskOrderChangedCallbacks =
+ new ArrayList<>();
/**
* The task display area is removed from the system and we are just waiting for all activities
@@ -181,7 +183,7 @@
* Returns the topmost stack on the display that is compatible with the input windowing mode
* and activity type. Null is no compatible stack on the display.
*/
- Task getStack(int windowingMode, int activityType) {
+ Task getRootTask(int windowingMode, int activityType) {
if (activityType == ACTIVITY_TYPE_HOME) {
return mRootHomeTask;
} else if (activityType == ACTIVITY_TYPE_RECENTS) {
@@ -208,7 +210,7 @@
}
@VisibleForTesting
- Task getTopStack() {
+ Task getTopRootTask() {
final int count = getChildCount();
return count > 0 ? getChildAt(count - 1) : null;
}
@@ -255,68 +257,68 @@
return visibleTasks;
}
- void onStackWindowingModeChanged(Task stack) {
- removeStackReferenceIfNeeded(stack);
- addStackReferenceIfNeeded(stack);
- if (stack == mRootPinnedTask && getTopStack() != stack) {
+ void onRootTaskWindowingModeChanged(Task rootTask) {
+ removeRootTaskReferenceIfNeeded(rootTask);
+ addRootTaskReferenceIfNeeded(rootTask);
+ if (rootTask == mRootPinnedTask && getTopRootTask() != rootTask) {
// Looks like this stack changed windowing mode to pinned. Move it to the top.
- positionChildAt(POSITION_TOP, stack, false /* includingParents */);
+ positionChildAt(POSITION_TOP, rootTask, false /* includingParents */);
}
}
- void addStackReferenceIfNeeded(Task stack) {
- if (stack.isActivityTypeHome()) {
+ void addRootTaskReferenceIfNeeded(Task rootTask) {
+ if (rootTask.isActivityTypeHome()) {
if (mRootHomeTask != null) {
- if (!stack.isDescendantOf(mRootHomeTask)) {
+ if (!rootTask.isDescendantOf(mRootHomeTask)) {
throw new IllegalArgumentException("addStackReferenceIfNeeded: home stack="
+ mRootHomeTask + " already exist on display=" + this
- + " stack=" + stack);
+ + " stack=" + rootTask);
}
} else {
- mRootHomeTask = stack;
+ mRootHomeTask = rootTask;
}
- } else if (stack.isActivityTypeRecents()) {
+ } else if (rootTask.isActivityTypeRecents()) {
if (mRootRecentsTask != null) {
- if (!stack.isDescendantOf(mRootRecentsTask)) {
+ if (!rootTask.isDescendantOf(mRootRecentsTask)) {
throw new IllegalArgumentException("addStackReferenceIfNeeded: recents stack="
+ mRootRecentsTask + " already exist on display=" + this
- + " stack=" + stack);
+ + " stack=" + rootTask);
}
} else {
- mRootRecentsTask = stack;
+ mRootRecentsTask = rootTask;
}
}
- if (!stack.isRootTask()) {
+ if (!rootTask.isRootTask()) {
return;
}
- final int windowingMode = stack.getWindowingMode();
+ final int windowingMode = rootTask.getWindowingMode();
if (windowingMode == WINDOWING_MODE_PINNED) {
if (mRootPinnedTask != null) {
throw new IllegalArgumentException(
"addStackReferenceIfNeeded: pinned stack=" + mRootPinnedTask
- + " already exist on display=" + this + " stack=" + stack);
+ + " already exist on display=" + this + " stack=" + rootTask);
}
- mRootPinnedTask = stack;
+ mRootPinnedTask = rootTask;
} else if (windowingMode == WINDOWING_MODE_SPLIT_SCREEN_PRIMARY) {
if (mRootSplitScreenPrimaryTask != null) {
throw new IllegalArgumentException(
"addStackReferenceIfNeeded: split screen primary stack="
+ mRootSplitScreenPrimaryTask
- + " already exist on display=" + this + " stack=" + stack);
+ + " already exist on display=" + this + " stack=" + rootTask);
}
- mRootSplitScreenPrimaryTask = stack;
+ mRootSplitScreenPrimaryTask = rootTask;
}
}
- void removeStackReferenceIfNeeded(Task stack) {
- if (stack == mRootHomeTask) {
+ void removeRootTaskReferenceIfNeeded(Task rootTask) {
+ if (rootTask == mRootHomeTask) {
mRootHomeTask = null;
- } else if (stack == mRootRecentsTask) {
+ } else if (rootTask == mRootRecentsTask) {
mRootRecentsTask = null;
- } else if (stack == mRootPinnedTask) {
+ } else if (rootTask == mRootPinnedTask) {
mRootPinnedTask = null;
- } else if (stack == mRootSplitScreenPrimaryTask) {
+ } else if (rootTask == mRootSplitScreenPrimaryTask) {
mRootSplitScreenPrimaryTask = null;
}
}
@@ -325,20 +327,20 @@
void addChild(Task task, int position) {
if (DEBUG_ROOT_TASK) Slog.d(TAG_WM, "Set task=" + task + " on taskDisplayArea=" + this);
- addStackReferenceIfNeeded(task);
- position = findPositionForStack(position, task, true /* adding */);
+ addRootTaskReferenceIfNeeded(task);
+ position = findPositionForRootTask(position, task, true /* adding */);
super.addChild(task, position);
mAtmService.updateSleepIfNeededLocked();
- onStackOrderChanged(task);
+ onRootTaskOrderChanged(task);
}
@Override
protected void removeChild(Task stack) {
super.removeChild(stack);
- onStackRemoved(stack);
+ onRootTaskRemoved(stack);
mAtmService.updateSleepIfNeededLocked();
- removeStackReferenceIfNeeded(stack);
+ removeRootTaskReferenceIfNeeded(stack);
}
@Override
@@ -367,7 +369,7 @@
if (!mDisplayContent.isTrusted() && !getParent().isOnTop()) {
includingParents = false;
}
- final int targetPosition = findPositionForStack(position, child, false /* adding */);
+ final int targetPosition = findPositionForRootTask(position, child, false /* adding */);
super.positionChildAt(targetPosition, child, false /* includingParents */);
if (includingParents && getParent() != null && (moveToTop || moveToBottom)) {
@@ -385,16 +387,16 @@
// preferred stack is set only when moving an existing stack to top instead of adding a new
// stack that may be too early (e.g. in the middle of launching or reparenting).
if (moveToTop && child.isFocusableAndVisible()) {
- mPreferredTopFocusableStack = child;
- } else if (mPreferredTopFocusableStack == child) {
- mPreferredTopFocusableStack = null;
+ mPreferredTopFocusableRootTask = child;
+ } else if (mPreferredTopFocusableRootTask == child) {
+ mPreferredTopFocusableRootTask = null;
}
// Update the top resumed activity because the preferred top focusable task may be changed.
mAtmService.mTaskSupervisor.updateTopResumedActivityIfNeeded();
if (mChildren.indexOf(child) != oldPosition) {
- onStackOrderChanged(child);
+ onRootTaskOrderChanged(child);
}
}
@@ -469,21 +471,21 @@
return 0;
}
- private int findMinPositionForStack(Task stack) {
+ private int findMinPositionForRootTask(Task rootTask) {
int minPosition = POSITION_BOTTOM;
for (int i = 0; i < mChildren.size(); ++i) {
- if (getPriority(getStackAt(i)) < getPriority(stack)) {
+ if (getPriority(getRootTaskAt(i)) < getPriority(rootTask)) {
minPosition = i;
} else {
break;
}
}
- if (stack.isAlwaysOnTop()) {
+ if (rootTask.isAlwaysOnTop()) {
// Since a stack could be repositioned while still being one of the children, we check
// if this always-on-top stack already exists and if so, set the minPosition to its
// previous position.
- final int currentIndex = getIndexOf(stack);
+ final int currentIndex = getIndexOf(rootTask);
if (currentIndex > minPosition) {
minPosition = currentIndex;
}
@@ -491,13 +493,13 @@
return minPosition;
}
- private int findMaxPositionForStack(Task stack) {
+ private int findMaxPositionForRootTask(Task rootTask) {
for (int i = mChildren.size() - 1; i >= 0; --i) {
- final Task curr = getStackAt(i);
+ final Task curr = getRootTaskAt(i);
// Since a stack could be repositioned while still being one of the children, we check
// if 'curr' is the same stack and skip it if so
- final boolean sameStack = curr == stack;
- if (getPriority(curr) <= getPriority(stack) && !sameStack) {
+ final boolean sameRootTask = curr == rootTask;
+ if (getPriority(curr) <= getPriority(rootTask) && !sameRootTask) {
return i;
}
}
@@ -519,16 +521,16 @@
* (including the Dream); otherwise, it is a normal non-always-on-top stack
*
* @param requestedPosition Position requested by caller.
- * @param stack Stack to be added or positioned.
+ * @param rootTask Root task to be added or positioned.
* @param adding Flag indicates whether we're adding a new stack or positioning an
* existing.
* @return The proper position for the stack.
*/
- private int findPositionForStack(int requestedPosition, Task stack, boolean adding) {
+ private int findPositionForRootTask(int requestedPosition, Task rootTask, boolean adding) {
// The max possible position we can insert the stack at.
- int maxPosition = findMaxPositionForStack(stack);
+ int maxPosition = findMaxPositionForRootTask(rootTask);
// The min possible position we can insert the stack at.
- int minPosition = findMinPositionForStack(stack);
+ int minPosition = findMinPositionForRootTask(rootTask);
// Cap the requested position to something reasonable for the previous position check
// below.
@@ -542,7 +544,7 @@
targetPosition = Math.min(targetPosition, maxPosition);
targetPosition = Math.max(targetPosition, minPosition);
- int prevPosition = mChildren.indexOf(stack);
+ int prevPosition = mChildren.indexOf(rootTask);
// The positions we calculated above (maxPosition, minPosition) do not take into
// consideration the following edge cases.
// 1) We need to adjust the position depending on the value "adding".
@@ -645,7 +647,7 @@
return SCREEN_ORIENTATION_UNSET;
}
- if (isStackVisible(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY)) {
+ if (isRootTaskVisible(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY)) {
// Apps and their containers are not allowed to specify an orientation while using
// root tasks...except for the home stack if it is not resizable and currently
// visible (top of) its root task.
@@ -672,7 +674,7 @@
} else {
// Apps and their containers are not allowed to specify an orientation of full screen
// tasks created by organizer. The organizer handles the orientation instead.
- final Task task = getTopStackInWindowingMode(WINDOWING_MODE_FULLSCREEN);
+ final Task task = getTopRootTaskInWindowingMode(WINDOWING_MODE_FULLSCREEN);
if (task != null && task.isVisible() && task.mCreatedByOrganizer) {
return SCREEN_ORIENTATION_UNSPECIFIED;
}
@@ -697,7 +699,7 @@
@Override
void assignChildLayers(SurfaceControl.Transaction t) {
- assignStackOrdering(t);
+ assignRootTaskOrdering(t);
for (int i = 0; i < mChildren.size(); i++) {
final Task s = mChildren.get(i);
@@ -705,37 +707,37 @@
}
}
- void assignStackOrdering(SurfaceControl.Transaction t) {
+ void assignRootTaskOrdering(SurfaceControl.Transaction t) {
if (getParent() == null) {
return;
}
- mTmpAlwaysOnTopStacks.clear();
- mTmpHomeStacks.clear();
- mTmpNormalStacks.clear();
+ mTmpAlwaysOnTopRootTasks.clear();
+ mTmpHomeRootTasks.clear();
+ mTmpNormalRootTasks.clear();
for (int i = 0; i < mChildren.size(); ++i) {
final Task s = mChildren.get(i);
if (s.isAlwaysOnTop()) {
- mTmpAlwaysOnTopStacks.add(s);
+ mTmpAlwaysOnTopRootTasks.add(s);
} else if (s.isActivityTypeHome()) {
- mTmpHomeStacks.add(s);
+ mTmpHomeRootTasks.add(s);
} else {
- mTmpNormalStacks.add(s);
+ mTmpNormalRootTasks.add(s);
}
}
int layer = 0;
// Place home stacks to the bottom.
- layer = adjustRootTaskLayer(t, mTmpHomeStacks, layer, false /* normalStacks */);
+ layer = adjustRootTaskLayer(t, mTmpHomeRootTasks, layer, false /* normalStacks */);
// The home animation layer is between the home stacks and the normal stacks.
final int layerForHomeAnimationLayer = layer++;
mTmpLayerForSplitScreenDividerAnchor = layer++;
mTmpLayerForAnimationLayer = layer++;
- layer = adjustRootTaskLayer(t, mTmpNormalStacks, layer, true /* normalStacks */);
+ layer = adjustRootTaskLayer(t, mTmpNormalRootTasks, layer, true /* normalStacks */);
// The boosted animation layer is between the normal stacks and the always on top
// stacks.
final int layerForBoostedAnimationLayer = layer++;
- adjustRootTaskLayer(t, mTmpAlwaysOnTopStacks, layer, false /* normalStacks */);
+ adjustRootTaskLayer(t, mTmpAlwaysOnTopRootTasks, layer, false /* normalStacks */);
t.setLayer(mHomeAppAnimationLayer, layerForHomeAnimationLayer);
t.setLayer(mAppAnimationLayer, mTmpLayerForAnimationLayer);
@@ -743,7 +745,7 @@
t.setLayer(mBoostedAppAnimationLayer, layerForBoostedAnimationLayer);
}
- private int adjustNormalStackLayer(Task s, int layer) {
+ private int adjustNormalRootTaskLayer(Task s, int layer) {
if (s.inSplitScreenWindowingMode()) {
// The split screen divider anchor is located above the split screen window.
mTmpLayerForSplitScreenDividerAnchor = layer++;
@@ -773,7 +775,7 @@
if (!stack.needsZBoost()) {
stack.assignLayer(t, startLayer++);
if (normalStacks) {
- startLayer = adjustNormalStackLayer(stack, startLayer);
+ startLayer = adjustNormalRootTaskLayer(stack, startLayer);
}
} else {
mTmpNeedsZBoostIndexes.add(i);
@@ -785,7 +787,7 @@
final Task stack = stacks.get(mTmpNeedsZBoostIndexes.get(i));
stack.assignLayer(t, startLayer++);
if (normalStacks) {
- startLayer = adjustNormalStackLayer(stack, startLayer);
+ startLayer = adjustNormalRootTaskLayer(stack, startLayer);
}
}
return startLayer;
@@ -849,22 +851,22 @@
}
}
- void onStackRemoved(Task stack) {
+ void onRootTaskRemoved(Task rootTask) {
if (ActivityTaskManagerDebugConfig.DEBUG_ROOT_TASK) {
- Slog.v(TAG_ROOT_TASK, "removeStack: detaching " + stack + " from displayId="
+ Slog.v(TAG_ROOT_TASK, "removeStack: detaching " + rootTask + " from displayId="
+ mDisplayContent.mDisplayId);
}
- if (mPreferredTopFocusableStack == stack) {
- mPreferredTopFocusableStack = null;
+ if (mPreferredTopFocusableRootTask == rootTask) {
+ mPreferredTopFocusableRootTask = null;
}
mDisplayContent.releaseSelfIfNeeded();
- onStackOrderChanged(stack);
+ onRootTaskOrderChanged(rootTask);
}
- void resetPreferredTopFocusableStackIfBelow(Task task) {
- if (mPreferredTopFocusableStack != null
- && mPreferredTopFocusableStack.compareTo(task) < 0) {
- mPreferredTopFocusableStack = null;
+ void resetPreferredTopFocusableRootTaskIfBelow(Task task) {
+ if (mPreferredTopFocusableRootTask != null
+ && mPreferredTopFocusableRootTask.compareTo(task) < 0) {
+ mPreferredTopFocusableRootTask = null;
}
}
@@ -894,9 +896,9 @@
}
}
- Task getStack(int rootTaskId) {
- for (int i = getStackCount() - 1; i >= 0; --i) {
- final Task stack = getStackAt(i);
+ Task getRootTask(int rootTaskId) {
+ for (int i = getRootTaskCount() - 1; i >= 0; --i) {
+ final Task stack = getRootTaskAt(i);
if (stack.getRootTaskId() == rootTaskId) {
return stack;
}
@@ -908,10 +910,10 @@
* Returns an existing stack compatible with the windowing mode and activity type or creates one
* if a compatible stack doesn't exist.
*
- * @see #getOrCreateStack(int, int, boolean, Intent, Task)
+ * @see #getOrCreateRootTask(int, int, boolean, Intent, Task)
*/
- Task getOrCreateStack(int windowingMode, int activityType, boolean onTop) {
- return getOrCreateStack(windowingMode, activityType, onTop, null /* intent */,
+ Task getOrCreateRootTask(int windowingMode, int activityType, boolean onTop) {
+ return getOrCreateRootTask(windowingMode, activityType, onTop, null /* intent */,
null /* candidateTask */);
}
@@ -921,17 +923,17 @@
* 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.
*
- * @see #getStack(int, int)
- * @see #createStack(int, int, boolean)
+ * @see #getRootTask(int, int)
+ * @see #createRootTask(int, int, boolean)
*/
- Task getOrCreateStack(int windowingMode, int activityType, boolean onTop,
+ Task getOrCreateRootTask(int windowingMode, int activityType, boolean onTop,
Intent intent, Task candidateTask) {
// Need to pass in a determined windowing mode to see if a new stack should be created,
// so use its parent's windowing mode if it is undefined.
- if (!alwaysCreateStack(
+ if (!alwaysCreateRootTask(
windowingMode != WINDOWING_MODE_UNDEFINED ? windowingMode : getWindowingMode(),
activityType)) {
- Task stack = getStack(windowingMode, activityType);
+ Task stack = getRootTask(windowingMode, activityType);
if (stack != null) {
return stack;
}
@@ -959,7 +961,7 @@
}
return stack;
}
- return createStack(windowingMode, activityType, onTop, null /*info*/, intent,
+ return createRootTask(windowingMode, activityType, onTop, null /*info*/, intent,
false /* createdByOrganizer */);
}
@@ -967,9 +969,9 @@
* Returns an existing stack compatible with the input params or creates one
* if a compatible stack doesn't exist.
*
- * @see #getOrCreateStack(int, int, boolean)
+ * @see #getOrCreateRootTask(int, int, boolean)
*/
- Task getOrCreateStack(@Nullable ActivityRecord r,
+ Task getOrCreateRootTask(@Nullable ActivityRecord r,
@Nullable ActivityOptions options, @Nullable Task candidateTask, int activityType,
boolean onTop) {
// First preference is the windowing mode in the activity options if set.
@@ -979,24 +981,24 @@
// UNDEFINED windowing mode is a valid result and means that the new stack will inherit
// it's display's windowing mode.
windowingMode = validateWindowingMode(windowingMode, r, candidateTask, activityType);
- return getOrCreateStack(windowingMode, activityType, onTop, null /* intent */,
+ return getOrCreateRootTask(windowingMode, activityType, onTop, null /* intent */,
candidateTask);
}
@VisibleForTesting
- int getNextStackId() {
+ int getNextRootTaskId() {
return mAtmService.mTaskSupervisor.getNextTaskIdForUser();
}
- Task createStack(int windowingMode, int activityType, boolean onTop) {
- return createStack(windowingMode, activityType, onTop, null /* info */, null /* intent */,
- false /* createdByOrganizer */);
+ Task createRootTask(int windowingMode, int activityType, boolean onTop) {
+ return createRootTask(windowingMode, activityType, onTop, null /* info */,
+ null /* intent */, false /* createdByOrganizer */);
}
- Task createStack(int windowingMode, int activityType, boolean onTop, ActivityInfo info,
+ Task createRootTask(int windowingMode, int activityType, boolean onTop, ActivityInfo info,
Intent intent, boolean createdByOrganizer) {
- return createStack(windowingMode, activityType, onTop, null /* info */, null /* intent */,
- false /* createdByOrganizer */ , false /* deferTaskAppear */,
+ return createRootTask(windowingMode, activityType, onTop, null /* info */,
+ null /* intent */, false /* createdByOrganizer */, false /* deferTaskAppear */,
null /* launchCookie */);
}
@@ -1022,7 +1024,7 @@
* creating.
* @return The newly created stack.
*/
- Task createStack(int windowingMode, int activityType, boolean onTop, ActivityInfo info,
+ Task createRootTask(int windowingMode, int activityType, boolean onTop, ActivityInfo info,
Intent intent, boolean createdByOrganizer, boolean deferTaskAppear,
IBinder launchCookie) {
if (activityType == ACTIVITY_TYPE_UNDEFINED && !createdByOrganizer) {
@@ -1034,7 +1036,7 @@
if (activityType != ACTIVITY_TYPE_STANDARD && activityType != ACTIVITY_TYPE_UNDEFINED) {
// For now there can be only one stack of a particular non-standard activity type on a
// display. So, get that ignoring whatever windowing mode it is currently in.
- Task stack = getStack(WINDOWING_MODE_UNDEFINED, activityType);
+ Task stack = getRootTask(WINDOWING_MODE_UNDEFINED, activityType);
if (stack != null) {
throw new IllegalArgumentException("Stack=" + stack + " of activityType="
+ activityType + " already on display=" + this + ". Can't have multiple.");
@@ -1054,8 +1056,8 @@
getRootPinnedTask().dismissPip();
}
- final int stackId = getNextStackId();
- return createStackUnchecked(windowingMode, activityType, stackId, onTop, info, intent,
+ final int stackId = getNextRootTaskId();
+ return createRootTaskUnchecked(windowingMode, activityType, stackId, onTop, info, intent,
createdByOrganizer, deferTaskAppear, launchCookie);
}
@@ -1065,15 +1067,15 @@
// Only split-screen windowing modes can do this currently...
return null;
}
- for (int i = getStackCount() - 1; i >= 0; --i) {
- final Task t = getStackAt(i);
+ for (int i = getRootTaskCount() - 1; i >= 0; --i) {
+ final Task t = getRootTaskAt(i);
if (!t.mCreatedByOrganizer || t.getRequestedOverrideWindowingMode() != windowingMode) {
continue;
}
// If not already set, pick a launch root which is not the one we are launching into.
if (mLaunchRootTask == null) {
- for (int j = 0, n = getStackCount(); j < n; ++j) {
- final Task tt = getStackAt(j);
+ for (int j = 0, n = getRootTaskCount(); j < n; ++j) {
+ final Task tt = getRootTaskAt(j);
if (tt.mCreatedByOrganizer && tt != t) {
mLaunchRootTask = tt;
break;
@@ -1086,7 +1088,7 @@
}
@VisibleForTesting
- Task createStackUnchecked(int windowingMode, int activityType, int stackId, boolean onTop,
+ Task createRootTaskUnchecked(int windowingMode, int activityType, int stackId, boolean onTop,
ActivityInfo info, Intent intent, boolean createdByOrganizer, boolean deferTaskAppear,
IBinder launchCookie) {
if (windowingMode == WINDOWING_MODE_PINNED && activityType != ACTIVITY_TYPE_STANDARD) {
@@ -1123,13 +1125,13 @@
* Get the preferred focusable stack in priority. If the preferred stack does not exist, find a
* focusable and visible stack from the top of stacks in this display.
*/
- Task getFocusedStack() {
- if (mPreferredTopFocusableStack != null) {
- return mPreferredTopFocusableStack;
+ Task getFocusedRootTask() {
+ if (mPreferredTopFocusableRootTask != null) {
+ return mPreferredTopFocusableRootTask;
}
- for (int i = getStackCount() - 1; i >= 0; --i) {
- final Task stack = getStackAt(i);
+ for (int i = getRootTaskCount() - 1; i >= 0; --i) {
+ final Task stack = getRootTaskAt(i);
if (stack.isFocusableAndVisible()) {
return stack;
}
@@ -1138,22 +1140,22 @@
return null;
}
- Task getNextFocusableStack(Task currentFocus, boolean ignoreCurrent) {
+ Task getNextFocusableRootTask(Task currentFocus, boolean ignoreCurrent) {
final int currentWindowingMode = currentFocus != null
? currentFocus.getWindowingMode() : WINDOWING_MODE_UNDEFINED;
Task candidate = null;
- for (int i = getStackCount() - 1; i >= 0; --i) {
- final Task stack = getStackAt(i);
- if (ignoreCurrent && stack == currentFocus) {
+ for (int i = getRootTaskCount() - 1; i >= 0; --i) {
+ final Task rootTask = getRootTaskAt(i);
+ if (ignoreCurrent && rootTask == currentFocus) {
continue;
}
- if (!stack.isFocusableAndVisible()) {
+ if (!rootTask.isFocusableAndVisible()) {
continue;
}
if (currentWindowingMode == WINDOWING_MODE_SPLIT_SCREEN_SECONDARY
- && candidate == null && stack.inSplitScreenPrimaryWindowingMode()) {
+ && candidate == null && rootTask.inSplitScreenPrimaryWindowingMode()) {
// If the currently focused stack is in split-screen secondary we save off the
// top primary split-screen stack as a candidate for focus because we might
// prefer focus to move to an other stack to avoid primary split-screen stack
@@ -1161,20 +1163,20 @@
// than the next split-screen stack. Assistant stack, I am looking at you...
// We only move the focus to the primary-split screen stack if there isn't a
// better alternative.
- candidate = stack;
+ candidate = rootTask;
continue;
}
- if (candidate != null && stack.inSplitScreenSecondaryWindowingMode()) {
+ if (candidate != null && rootTask.inSplitScreenSecondaryWindowingMode()) {
// Use the candidate stack since we are now at the secondary split-screen.
return candidate;
}
- return stack;
+ return rootTask;
}
return candidate;
}
ActivityRecord getFocusedActivity() {
- final Task focusedStack = getFocusedStack();
+ final Task focusedStack = getFocusedRootTask();
if (focusedStack == null) {
return null;
}
@@ -1194,8 +1196,8 @@
return resumedActivity;
}
- Task getLastFocusedStack() {
- return mLastFocusedStack;
+ Task getLastFocusedRootTask() {
+ return mLastFocusedRootTask;
}
void updateLastFocusedRootTask(Task prevFocusedTask, String updateLastFocusedTaskReason) {
@@ -1203,7 +1205,7 @@
return;
}
- final Task currentFocusedTask = getFocusedStack();
+ final Task currentFocusedTask = getFocusedRootTask();
if (currentFocusedTask == prevFocusedTask) {
return;
}
@@ -1214,27 +1216,27 @@
currentFocusedTask.mLastPausedActivity = null;
}
- mLastFocusedStack = prevFocusedTask;
+ mLastFocusedRootTask = prevFocusedTask;
EventLogTags.writeWmFocusedStack(mRootWindowContainer.mCurrentUser,
mDisplayContent.mDisplayId,
currentFocusedTask == null ? -1 : currentFocusedTask.getRootTaskId(),
- mLastFocusedStack == null ? -1 : mLastFocusedStack.getRootTaskId(),
+ mLastFocusedRootTask == null ? -1 : mLastFocusedRootTask.getRootTaskId(),
updateLastFocusedTaskReason);
}
boolean allResumedActivitiesComplete() {
- for (int stackNdx = getStackCount() - 1; stackNdx >= 0; --stackNdx) {
- final ActivityRecord r = getStackAt(stackNdx).getResumedActivity();
+ for (int stackNdx = getRootTaskCount() - 1; stackNdx >= 0; --stackNdx) {
+ final ActivityRecord r = getRootTaskAt(stackNdx).getResumedActivity();
if (r != null && !r.isState(RESUMED)) {
return false;
}
}
- final Task currentFocusedStack = getFocusedStack();
+ final Task currentFocusedStack = getFocusedRootTask();
if (ActivityTaskManagerDebugConfig.DEBUG_ROOT_TASK) {
Slog.d(TAG_ROOT_TASK, "allResumedActivitiesComplete: mLastFocusedStack changing from="
- + mLastFocusedStack + " to=" + currentFocusedStack);
+ + mLastFocusedRootTask + " to=" + currentFocusedStack);
}
- mLastFocusedStack = currentFocusedStack;
+ mLastFocusedRootTask = currentFocusedStack;
return true;
}
@@ -1249,10 +1251,10 @@
* @param resuming The resuming activity.
* @return {@code true} if any activity was paused as a result of this call.
*/
- boolean pauseBackStacks(boolean userLeaving, ActivityRecord resuming) {
+ boolean pauseBackTasks(boolean userLeaving, ActivityRecord resuming) {
boolean someActivityPaused = false;
- for (int stackNdx = getStackCount() - 1; stackNdx >= 0; --stackNdx) {
- final Task stack = getStackAt(stackNdx);
+ for (int stackNdx = getRootTaskCount() - 1; stackNdx >= 0; --stackNdx) {
+ final Task stack = getRootTaskAt(stackNdx);
final ActivityRecord resumedActivity = stack.getResumedActivity();
if (resumedActivity != null
&& (stack.getVisibility(resuming) != TASK_VISIBILITY_VISIBLE
@@ -1272,8 +1274,8 @@
void findTaskLocked(final ActivityRecord r, final boolean isPreferredDisplayArea,
RootWindowContainer.FindTaskResult result) {
mTmpFindTaskResult.clear();
- for (int stackNdx = getStackCount() - 1; stackNdx >= 0; --stackNdx) {
- final Task stack = getStackAt(stackNdx);
+ for (int stackNdx = getRootTaskCount() - 1; stackNdx >= 0; --stackNdx) {
+ final Task stack = getRootTaskAt(stackNdx);
if (!r.hasCompatibleActivityType(stack) && stack.isLeafTask()) {
ProtoLog.d(WM_DEBUG_TASKS, "Skipping stack: (mismatch activity/stack) "
+ "%s", stack);
@@ -1367,7 +1369,7 @@
// The focused task could be a non-resizeable fullscreen root task that is on top of the
// other split-screen tasks, therefore had to dismiss split-screen, make sure the current
// focused root task can still be on top after dismissal
- final Task rootTask = getFocusedStack();
+ final Task rootTask = getFocusedRootTask();
final Task toTop =
rootTask != null && !rootTask.inSplitScreenWindowingMode() ? rootTask : null;
onSplitScreenModeDismissed(toTop);
@@ -1380,9 +1382,9 @@
moveSplitScreenTasksToFullScreen();
} finally {
final Task topFullscreenStack = toTop != null
- ? toTop : getTopStackInWindowingMode(WINDOWING_MODE_FULLSCREEN);
+ ? toTop : getTopRootTaskInWindowingMode(WINDOWING_MODE_FULLSCREEN);
final Task homeStack = getOrCreateRootHomeTask();
- if (homeStack != null && ((topFullscreenStack != null && !isTopStack(homeStack))
+ if (homeStack != null && ((topFullscreenStack != null && !isTopRootTask(homeStack))
|| toTop != null)) {
// Whenever split-screen is dismissed we want the home stack directly behind the
// current top fullscreen stack so it shows up when the top stack is finished.
@@ -1556,8 +1558,8 @@
return windowingMode;
}
- boolean isTopStack(Task stack) {
- return stack == getTopStack();
+ boolean isTopRootTask(Task stack) {
+ return stack == getTopRootTask();
}
ActivityRecord topRunningActivity() {
@@ -1575,15 +1577,15 @@
*/
ActivityRecord topRunningActivity(boolean considerKeyguardState) {
ActivityRecord topRunning = null;
- final Task focusedStack = getFocusedStack();
+ final Task focusedStack = getFocusedRootTask();
if (focusedStack != null) {
topRunning = focusedStack.topRunningActivity();
}
// Look in other focusable stacks.
if (topRunning == null) {
- for (int i = getStackCount() - 1; i >= 0; --i) {
- final Task stack = getStackAt(i);
+ for (int i = getRootTaskCount() - 1; i >= 0; --i) {
+ final Task stack = getRootTaskAt(i);
// Only consider focusable stacks other than the current focused one.
if (stack == focusedStack || !stack.isTopActivityFocusable()) {
continue;
@@ -1607,13 +1609,11 @@
return topRunning;
}
- // TODO (b/157876447): switch to Task related name
- protected int getStackCount() {
+ protected int getRootTaskCount() {
return mChildren.size();
}
- // TODO (b/157876447): switch to Task related name
- protected Task getStackAt(int index) {
+ protected Task getRootTaskAt(int index) {
return mChildren.get(index);
}
@@ -1633,7 +1633,7 @@
Task getOrCreateRootHomeTask(boolean onTop) {
Task homeTask = getRootHomeTask();
if (homeTask == null && mDisplayContent.supportsSystemDecorations()) {
- homeTask = createStack(WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_HOME, onTop);
+ homeTask = createRootTask(WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_HOME, onTop);
}
return homeTask;
}
@@ -1647,14 +1647,14 @@
* Returns the topmost stack on the display that is compatible with the input windowing mode.
* Null is no compatible stack on the display.
*/
- Task getTopStackInWindowingMode(int windowingMode) {
- return getStack(windowingMode, ACTIVITY_TYPE_UNDEFINED);
+ Task getTopRootTaskInWindowingMode(int windowingMode) {
+ return getRootTask(windowingMode, ACTIVITY_TYPE_UNDEFINED);
}
- void moveHomeStackToFront(String reason) {
- final Task homeStack = getOrCreateRootHomeTask();
- if (homeStack != null) {
- homeStack.moveToFront(reason);
+ void moveHomeRootTaskToFront(String reason) {
+ final Task homeRootTask = getOrCreateRootHomeTask();
+ if (homeRootTask != null) {
+ homeRootTask.moveToFront(reason);
}
}
@@ -1665,7 +1665,7 @@
void moveHomeActivityToTop(String reason) {
final ActivityRecord top = getHomeActivity();
if (top == null) {
- moveHomeStackToFront(reason);
+ moveHomeRootTaskToFront(reason);
return;
}
top.moveFocusableActivityToTop(reason);
@@ -1697,25 +1697,27 @@
/**
* Adjusts the {@param stack} behind the last visible stack in the display if necessary.
- * Generally used in conjunction with {@link #moveStackBehindStack}.
+ * Generally used in conjunction with {@link #moveRootTaskBehindRootTask}.
*/
// TODO(b/151575894): Remove special stack movement methods.
- void moveStackBehindBottomMostVisibleStack(Task stack) {
- if (stack.shouldBeVisible(null)) {
+ void moveRootTaskBehindBottomMostVisibleRootTask(Task rootTask) {
+ if (rootTask.shouldBeVisible(null)) {
// Skip if the stack is already visible
return;
}
// Move the stack to the bottom to not affect the following visibility checks
- stack.getParent().positionChildAt(POSITION_BOTTOM, stack, false /* includingParents */);
+ rootTask.getParent().positionChildAt(POSITION_BOTTOM, rootTask,
+ false /* includingParents */);
// Find the next position where the stack should be placed
- final boolean isRootTask = stack.isRootTask();
- final int numStacks = isRootTask ? getStackCount() : stack.getParent().getChildCount();
- for (int stackNdx = 0; stackNdx < numStacks; stackNdx++) {
- final Task s = isRootTask ? getStackAt(stackNdx)
- : (Task) stack.getParent().getChildAt(stackNdx);
- if (s == stack) {
+ final boolean isRootTask = rootTask.isRootTask();
+ final int numRootTasks =
+ isRootTask ? getRootTaskCount() : rootTask.getParent().getChildCount();
+ for (int rootTaskNdx = 0; rootTaskNdx < numRootTasks; rootTaskNdx++) {
+ final Task s = isRootTask ? getRootTaskAt(rootTaskNdx)
+ : (Task) rootTask.getParent().getChildAt(rootTaskNdx);
+ if (s == rootTask) {
continue;
}
final int winMode = s.getWindowingMode();
@@ -1723,8 +1725,9 @@
|| winMode == WINDOWING_MODE_SPLIT_SCREEN_SECONDARY;
if (s.shouldBeVisible(null) && isValidWindowingMode) {
// Move the provided stack to behind this stack
- final int position = Math.max(0, stackNdx - 1);
- stack.getParent().positionChildAt(position, stack, false /*includingParents */);
+ final int position = Math.max(0, rootTaskNdx - 1);
+ rootTask.getParent().positionChildAt(position, rootTask,
+ false /*includingParents */);
break;
}
}
@@ -1733,15 +1736,16 @@
/**
* Moves the {@param stack} behind the given {@param behindStack} if possible. If
* {@param behindStack} is not currently in the display, then then the stack is moved to the
- * back. Generally used in conjunction with {@link #moveStackBehindBottomMostVisibleStack}.
+ * back. Generally used in conjunction with
+ * {@link #moveRootTaskBehindBottomMostVisibleRootTask}.
*/
- void moveStackBehindStack(Task stack, Task behindStack) {
- if (behindStack == null || behindStack == stack) {
+ void moveRootTaskBehindRootTask(Task rootTask, Task behindRootTask) {
+ if (behindRootTask == null || behindRootTask == rootTask) {
return;
}
- final WindowContainer parent = stack.getParent();
- if (parent == null || parent != behindStack.getParent()) {
+ final WindowContainer parent = rootTask.getParent();
+ if (parent == null || parent != behindRootTask.getParent()) {
return;
}
@@ -1749,12 +1753,12 @@
// list, so we need to adjust the insertion index to account for the removed index
// TODO: Remove this logic when WindowContainer.positionChildAt() is updated to adjust the
// position internally
- final int stackIndex = parent.mChildren.indexOf(stack);
- final int behindStackIndex = parent.mChildren.indexOf(behindStack);
+ final int stackIndex = parent.mChildren.indexOf(rootTask);
+ final int behindStackIndex = parent.mChildren.indexOf(behindRootTask);
final int insertIndex = stackIndex <= behindStackIndex
? behindStackIndex - 1 : behindStackIndex;
final int position = Math.max(0, insertIndex);
- parent.positionChildAt(position, stack, false /* includingParents */);
+ parent.positionChildAt(position, rootTask, false /* includingParents */);
}
boolean hasPinnedTask() {
@@ -1765,20 +1769,20 @@
* @return the stack currently above the {@param stack}. Can be null if the {@param stack} is
* already top-most.
*/
- static Task getStackAbove(Task stack) {
- final WindowContainer wc = stack.getParent();
- final int index = wc.mChildren.indexOf(stack) + 1;
+ static Task getRootTaskAbove(Task rootTask) {
+ final WindowContainer wc = rootTask.getParent();
+ final int index = wc.mChildren.indexOf(rootTask) + 1;
return (index < wc.mChildren.size()) ? (Task) wc.mChildren.get(index) : null;
}
/** Returns true if the stack in the windowing mode is visible. */
- boolean isStackVisible(int windowingMode) {
- final Task stack = getTopStackInWindowingMode(windowingMode);
- return stack != null && stack.isVisible();
+ boolean isRootTaskVisible(int windowingMode) {
+ final Task rootTask = getTopRootTaskInWindowingMode(windowingMode);
+ return rootTask != null && rootTask.isVisible();
}
- void removeStack(Task stack) {
- removeChild(stack);
+ void removeRootTask(Task rootTask) {
+ removeChild(rootTask);
}
int getDisplayId() {
@@ -1794,27 +1798,27 @@
* only used by the {@link RecentsAnimation} to determine whether to interrupt and cancel the
* current animation when the system state changes.
*/
- void registerStackOrderChangedListener(OnStackOrderChangedListener listener) {
- if (!mStackOrderChangedCallbacks.contains(listener)) {
- mStackOrderChangedCallbacks.add(listener);
+ void registerRootTaskOrderChangedListener(OnRootTaskOrderChangedListener listener) {
+ if (!mRootTaskOrderChangedCallbacks.contains(listener)) {
+ mRootTaskOrderChangedCallbacks.add(listener);
}
}
/**
* Removes a previously registered stack order change listener.
*/
- void unregisterStackOrderChangedListener(OnStackOrderChangedListener listener) {
- mStackOrderChangedCallbacks.remove(listener);
+ void unregisterRootTaskOrderChangedListener(OnRootTaskOrderChangedListener listener) {
+ mRootTaskOrderChangedCallbacks.remove(listener);
}
/**
- * Notifies of a stack order change
+ * Notifies of a root task order change
*
- * @param stack The stack which triggered the order change
+ * @param rootTask The root task which triggered the order change
*/
- void onStackOrderChanged(Task stack) {
- for (int i = mStackOrderChangedCallbacks.size() - 1; i >= 0; i--) {
- mStackOrderChangedCallbacks.get(i).onStackOrderChanged(stack);
+ void onRootTaskOrderChanged(Task rootTask) {
+ for (int i = mRootTaskOrderChangedCallbacks.size() - 1; i >= 0; i--) {
+ mRootTaskOrderChangedCallbacks.get(i).onRootTaskOrderChanged(rootTask);
}
}
@@ -1826,16 +1830,16 @@
/**
* Callback for when the order of the stacks in the display changes.
*/
- interface OnStackOrderChangedListener {
- void onStackOrderChanged(Task stack);
+ interface OnRootTaskOrderChangedListener {
+ void onRootTaskOrderChanged(Task rootTask);
}
void ensureActivitiesVisible(ActivityRecord starting, int configChanges,
boolean preserveWindows, boolean notifyClients, boolean userLeaving) {
mAtmService.mTaskSupervisor.beginActivityVisibilityUpdate();
try {
- for (int stackNdx = getStackCount() - 1; stackNdx >= 0; --stackNdx) {
- final Task stack = getStackAt(stackNdx);
+ for (int stackNdx = getRootTaskCount() - 1; stackNdx >= 0; --stackNdx) {
+ final Task stack = getRootTaskAt(stackNdx);
stack.ensureActivitiesVisible(starting, configChanges, preserveWindows,
notifyClients, userLeaving);
}
@@ -1857,7 +1861,7 @@
* @return last reparented stack, or {@code null} if the stacks had to be destroyed.
*/
Task remove() {
- mPreferredTopFocusableStack = null;
+ mPreferredTopFocusableRootTask = null;
// TODO(b/153090332): Allow setting content removal mode per task display area
final boolean destroyContentOnRemoval = mDisplayContent.shouldDestroyContentOnRemove();
final TaskDisplayArea toDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea();
@@ -1869,13 +1873,13 @@
// related WindowContainer will also be removed. So, we set display area as removed after
// reparenting stack finished.
// Keep the order from bottom to top.
- int numStacks = getStackCount();
+ int numStacks = getRootTaskCount();
final boolean splitScreenActivated = toDisplayArea.isSplitScreenModeActivated();
final Task rootStack = splitScreenActivated ? toDisplayArea
- .getTopStackInWindowingMode(WINDOWING_MODE_SPLIT_SCREEN_SECONDARY) : null;
+ .getTopRootTaskInWindowingMode(WINDOWING_MODE_SPLIT_SCREEN_SECONDARY) : null;
for (int stackNdx = 0; stackNdx < numStacks; stackNdx++) {
- final Task stack = getStackAt(stackNdx);
+ final Task stack = getRootTaskAt(stackNdx);
// Always finish non-standard type stacks and stacks created by a organizer.
// TODO: For stacks created by organizer, consider reparenting children tasks if the use
// case arises in the future.
@@ -1895,8 +1899,8 @@
}
// Stacks may be removed from this display. Ensure each stack will be processed
// and the loop will end.
- stackNdx -= numStacks - getStackCount();
- numStacks = getStackCount();
+ stackNdx -= numStacks - getRootTaskCount();
+ numStacks = getRootTaskCount();
}
if (lastReparentedStack != null && splitScreenActivated) {
if (!lastReparentedStack.supportsSplitScreenWindowingMode()) {
@@ -1935,18 +1939,19 @@
pw.println(prefix + "TaskDisplayArea " + getName());
final String doublePrefix = prefix + " ";
super.dump(pw, doublePrefix, dumpAll);
- if (mPreferredTopFocusableStack != null) {
- pw.println(doublePrefix + "mPreferredTopFocusableStack=" + mPreferredTopFocusableStack);
+ if (mPreferredTopFocusableRootTask != null) {
+ pw.println(doublePrefix + "mPreferredTopFocusableRootTask="
+ + mPreferredTopFocusableRootTask);
}
- if (mLastFocusedStack != null) {
- pw.println(doublePrefix + "mLastFocusedStack=" + mLastFocusedStack);
+ if (mLastFocusedRootTask != null) {
+ pw.println(doublePrefix + "mLastFocusedRootTask=" + mLastFocusedRootTask);
}
final String triplePrefix = doublePrefix + " ";
pw.println(doublePrefix + "Application tokens in top down Z order:");
- for (int stackNdx = getChildCount() - 1; stackNdx >= 0; --stackNdx) {
- final Task stack = getChildAt(stackNdx);
- pw.println(doublePrefix + "* " + stack);
- stack.dump(pw, triplePrefix, dumpAll);
+ for (int rootTaskNdx = getChildCount() - 1; rootTaskNdx >= 0; --rootTaskNdx) {
+ final Task rootTask = getChildAt(rootTaskNdx);
+ pw.println(doublePrefix + "* " + rootTask);
+ rootTask.dump(pw, triplePrefix, dumpAll);
}
}
}
diff --git a/services/core/java/com/android/server/wm/TaskLaunchParamsModifier.java b/services/core/java/com/android/server/wm/TaskLaunchParamsModifier.java
index 8b2fa52..9d36b84 100644
--- a/services/core/java/com/android/server/wm/TaskLaunchParamsModifier.java
+++ b/services/core/java/com/android/server/wm/TaskLaunchParamsModifier.java
@@ -796,9 +796,9 @@
@NonNull Rect inOutBounds) {
final List<Rect> taskBoundsToCheck = new ArrayList<>();
display.forAllTaskDisplayAreas(taskDisplayArea -> {
- int numStacks = taskDisplayArea.getStackCount();
+ int numStacks = taskDisplayArea.getRootTaskCount();
for (int sNdx = 0; sNdx < numStacks; ++sNdx) {
- final Task task = taskDisplayArea.getStackAt(sNdx);
+ final Task task = taskDisplayArea.getRootTaskAt(sNdx);
if (!task.inFreeformWindowingMode()) {
continue;
}
diff --git a/services/core/java/com/android/server/wm/TaskOrganizerController.java b/services/core/java/com/android/server/wm/TaskOrganizerController.java
index 009a7ef..e635219 100644
--- a/services/core/java/com/android/server/wm/TaskOrganizerController.java
+++ b/services/core/java/com/android/server/wm/TaskOrganizerController.java
@@ -478,7 +478,7 @@
// We want to defer the task appear signal until the task is fully created and attached to
// to the hierarchy so that the complete starting configuration is in the task info we send
// over to the organizer.
- final Task task = display.getDefaultTaskDisplayArea().createStack(windowingMode,
+ final Task task = display.getDefaultTaskDisplayArea().createRootTask(windowingMode,
ACTIVITY_TYPE_UNDEFINED, false /* onTop */, null /* info */, new Intent(),
true /* createdByOrganizer */, true /* deferTaskAppear */, launchCookie);
task.setDeferTaskAppear(false /* deferTaskAppear */);
@@ -688,8 +688,8 @@
}
ArrayList<RunningTaskInfo> out = new ArrayList<>();
dc.forAllTaskDisplayAreas(taskDisplayArea -> {
- for (int sNdx = taskDisplayArea.getStackCount() - 1; sNdx >= 0; --sNdx) {
- final Task task = taskDisplayArea.getStackAt(sNdx);
+ for (int sNdx = taskDisplayArea.getRootTaskCount() - 1; sNdx >= 0; --sNdx) {
+ final Task task = taskDisplayArea.getRootTaskAt(sNdx);
if (activityTypes != null
&& !ArrayUtils.contains(activityTypes, task.getActivityType())) {
continue;
diff --git a/services/core/java/com/android/server/wm/WallpaperController.java b/services/core/java/com/android/server/wm/WallpaperController.java
index 7d61c19..7809cbc 100644
--- a/services/core/java/com/android/server/wm/WallpaperController.java
+++ b/services/core/java/com/android/server/wm/WallpaperController.java
@@ -502,7 +502,8 @@
private void findWallpaperTarget() {
mFindResults.reset();
- if (mDisplayContent.getDefaultTaskDisplayArea().isStackVisible(WINDOWING_MODE_FREEFORM)) {
+ if (mDisplayContent.getDefaultTaskDisplayArea()
+ .isRootTaskVisible(WINDOWING_MODE_FREEFORM)) {
// In freeform mode we set the wallpaper as its own target, so we don't need an
// additional window to make it visible.
mFindResults.setUseTopWallpaperAsTarget(true);
diff --git a/services/core/java/com/android/server/wm/WindowManagerService.java b/services/core/java/com/android/server/wm/WindowManagerService.java
index c585f22..7efe3cd 100644
--- a/services/core/java/com/android/server/wm/WindowManagerService.java
+++ b/services/core/java/com/android/server/wm/WindowManagerService.java
@@ -2918,7 +2918,7 @@
}
void getStackBounds(int windowingMode, int activityType, Rect bounds) {
- final Task stack = mRoot.getStack(windowingMode, activityType);
+ final Task stack = mRoot.getRootTask(windowingMode, activityType);
if (stack != null) {
stack.getBounds(bounds);
return;
diff --git a/services/tests/wmtests/src/com/android/server/wm/ActivityDisplayTests.java b/services/tests/wmtests/src/com/android/server/wm/ActivityDisplayTests.java
index 9a6eb1c..99bd0d7 100644
--- a/services/tests/wmtests/src/com/android/server/wm/ActivityDisplayTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/ActivityDisplayTests.java
@@ -68,16 +68,16 @@
mRootWindowContainer.getDefaultDisplay().getDefaultTaskDisplayArea();
final Task stack =
new TaskBuilder(mSupervisor).setOnTop(!ON_TOP).setCreateActivity(true).build();
- final Task prevFocusedStack = taskDisplayAreas.getFocusedStack();
+ final Task prevFocusedStack = taskDisplayAreas.getFocusedRootTask();
stack.moveToFront("moveStackToFront");
// After moving the stack to front, the previous focused should be the last focused.
assertTrue(stack.isFocusedStackOnDisplay());
- assertEquals(prevFocusedStack, taskDisplayAreas.getLastFocusedStack());
+ assertEquals(prevFocusedStack, taskDisplayAreas.getLastFocusedRootTask());
stack.moveToBack("moveStackToBack", null /* task */);
// After moving the stack to back, the stack should be the last focused.
- assertEquals(stack, taskDisplayAreas.getLastFocusedStack());
+ assertEquals(stack, taskDisplayAreas.getLastFocusedRootTask());
}
/**
@@ -88,7 +88,7 @@
public void testFullscreenStackCanBeFocusedWhenFocusablePinnedStackExists() {
// Create a pinned stack and move to front.
final Task pinnedStack = mRootWindowContainer.getDefaultTaskDisplayArea()
- .createStack(WINDOWING_MODE_PINNED, ACTIVITY_TYPE_STANDARD, ON_TOP);
+ .createRootTask(WINDOWING_MODE_PINNED, ACTIVITY_TYPE_STANDARD, ON_TOP);
final Task pinnedTask = new TaskBuilder(mAtm.mTaskSupervisor)
.setParentTask(pinnedStack).build();
new ActivityBuilder(mAtm).setActivityFlags(FLAG_ALWAYS_FOCUSABLE)
@@ -108,7 +108,7 @@
}
/**
- * Test {@link TaskDisplayArea#mPreferredTopFocusableStack} will be cleared when
+ * Test {@link TaskDisplayArea#mPreferredTopFocusableRootTask} will be cleared when
* the stack is removed or moved to back, and the focused stack will be according to z-order.
*/
@Test
@@ -128,7 +128,7 @@
assertTrue(stack1.isFocusedStackOnDisplay());
// Stack2 should be focused after removing stack1.
- stack1.getDisplayArea().removeStack(stack1);
+ stack1.getDisplayArea().removeRootTask(stack1);
assertTrue(stack2.isFocusedStackOnDisplay());
}
@@ -155,12 +155,12 @@
display.remove();
// The removed display should have no focused stack and its home stack should never resume.
- assertNull(display.getFocusedStack());
+ assertNull(display.getFocusedRootTask());
verify(homeStack, never()).resumeTopActivityUncheckedLocked(any(), any());
}
private Task createFullscreenStackWithSimpleActivityAt(DisplayContent display) {
- final Task fullscreenStack = display.getDefaultTaskDisplayArea().createStack(
+ final Task fullscreenStack = display.getDefaultTaskDisplayArea().createRootTask(
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, ON_TOP);
final Task fullscreenTask = new TaskBuilder(mAtm.mTaskSupervisor)
.setParentTask(fullscreenStack).build();
@@ -191,7 +191,7 @@
// Move stack with activity to top.
stack.moveToFront("testStackToFront");
- assertEquals(stack, display.getFocusedStack());
+ assertEquals(stack, display.getFocusedRootTask());
assertEquals(activity, display.topRunningActivity());
assertNull(display.topRunningActivity(true /* considerKeyguardState */));
@@ -207,7 +207,7 @@
// Move empty stack to front. The running activity in focusable stack which below the
// empty stack should be returned.
emptyStack.moveToFront("emptyStackToFront");
- assertEquals(stack, display.getFocusedStack());
+ assertEquals(stack, display.getFocusedRootTask());
assertTopRunningActivity(showWhenLockedActivity, display);
}
@@ -222,7 +222,7 @@
@Test
public void testAlwaysOnTopStackLocation() {
final TaskDisplayArea taskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea();
- final Task alwaysOnTopStack = taskDisplayArea.createStack(WINDOWING_MODE_FREEFORM,
+ final Task alwaysOnTopStack = taskDisplayArea.createRootTask(WINDOWING_MODE_FREEFORM,
ACTIVITY_TYPE_STANDARD, true /* onTop */);
final ActivityRecord activity = new ActivityBuilder(mAtm)
.setTask(alwaysOnTopStack).build();
@@ -232,31 +232,31 @@
assertTrue(alwaysOnTopStack.isAlwaysOnTop());
// Ensure always on top state is synced to the children of the stack.
assertTrue(alwaysOnTopStack.getTopNonFinishingActivity().isAlwaysOnTop());
- assertEquals(alwaysOnTopStack, taskDisplayArea.getTopStack());
+ assertEquals(alwaysOnTopStack, taskDisplayArea.getTopRootTask());
- final Task pinnedStack = taskDisplayArea.createStack(
+ final Task pinnedStack = taskDisplayArea.createRootTask(
WINDOWING_MODE_PINNED, ACTIVITY_TYPE_STANDARD, true /* onTop */);
assertEquals(pinnedStack, taskDisplayArea.getRootPinnedTask());
- assertEquals(pinnedStack, taskDisplayArea.getTopStack());
+ assertEquals(pinnedStack, taskDisplayArea.getTopRootTask());
- final Task anotherAlwaysOnTopStack = taskDisplayArea.createStack(
+ final Task anotherAlwaysOnTopStack = taskDisplayArea.createRootTask(
WINDOWING_MODE_FREEFORM, ACTIVITY_TYPE_STANDARD, true /* onTop */);
anotherAlwaysOnTopStack.setAlwaysOnTop(true);
taskDisplayArea.positionChildAt(POSITION_TOP, anotherAlwaysOnTopStack,
false /* includingParents */);
assertTrue(anotherAlwaysOnTopStack.isAlwaysOnTop());
- int topPosition = taskDisplayArea.getStackCount() - 1;
+ int topPosition = taskDisplayArea.getRootTaskCount() - 1;
// Ensure the new alwaysOnTop stack is put below the pinned stack, but on top of the
// existing alwaysOnTop stack.
- assertEquals(anotherAlwaysOnTopStack, taskDisplayArea.getStackAt(topPosition - 1));
+ assertEquals(anotherAlwaysOnTopStack, taskDisplayArea.getRootTaskAt(topPosition - 1));
- final Task nonAlwaysOnTopStack = taskDisplayArea.createStack(
+ final Task nonAlwaysOnTopStack = taskDisplayArea.createRootTask(
WINDOWING_MODE_FREEFORM, ACTIVITY_TYPE_STANDARD, true /* onTop */);
assertEquals(taskDisplayArea, nonAlwaysOnTopStack.getDisplayArea());
- topPosition = taskDisplayArea.getStackCount() - 1;
+ topPosition = taskDisplayArea.getRootTaskCount() - 1;
// Ensure the non-alwaysOnTop stack is put below the three alwaysOnTop stacks, but above the
// existing other non-alwaysOnTop stacks.
- assertEquals(nonAlwaysOnTopStack, taskDisplayArea.getStackAt(topPosition - 3));
+ assertEquals(nonAlwaysOnTopStack, taskDisplayArea.getRootTaskAt(topPosition - 3));
anotherAlwaysOnTopStack.setAlwaysOnTop(false);
taskDisplayArea.positionChildAt(POSITION_TOP, anotherAlwaysOnTopStack,
@@ -264,37 +264,37 @@
assertFalse(anotherAlwaysOnTopStack.isAlwaysOnTop());
// Ensure, when always on top is turned off for a stack, the stack is put just below all
// other always on top stacks.
- assertEquals(anotherAlwaysOnTopStack, taskDisplayArea.getStackAt(topPosition - 2));
+ assertEquals(anotherAlwaysOnTopStack, taskDisplayArea.getRootTaskAt(topPosition - 2));
anotherAlwaysOnTopStack.setAlwaysOnTop(true);
// Ensure always on top state changes properly when windowing mode changes.
anotherAlwaysOnTopStack.setWindowingMode(WINDOWING_MODE_FULLSCREEN);
assertFalse(anotherAlwaysOnTopStack.isAlwaysOnTop());
- assertEquals(anotherAlwaysOnTopStack, taskDisplayArea.getStackAt(topPosition - 2));
+ assertEquals(anotherAlwaysOnTopStack, taskDisplayArea.getRootTaskAt(topPosition - 2));
anotherAlwaysOnTopStack.setWindowingMode(WINDOWING_MODE_FREEFORM);
assertTrue(anotherAlwaysOnTopStack.isAlwaysOnTop());
- assertEquals(anotherAlwaysOnTopStack, taskDisplayArea.getStackAt(topPosition - 1));
+ assertEquals(anotherAlwaysOnTopStack, taskDisplayArea.getRootTaskAt(topPosition - 1));
- final Task dreamStack = taskDisplayArea.createStack(
+ final Task dreamStack = taskDisplayArea.createRootTask(
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_DREAM, true /* onTop */);
assertEquals(taskDisplayArea, dreamStack.getDisplayArea());
assertTrue(dreamStack.isAlwaysOnTop());
- topPosition = taskDisplayArea.getStackCount() - 1;
+ topPosition = taskDisplayArea.getRootTaskCount() - 1;
// Ensure dream shows above all activities, including PiP
- assertEquals(dreamStack, taskDisplayArea.getTopStack());
- assertEquals(pinnedStack, taskDisplayArea.getStackAt(topPosition - 1));
+ assertEquals(dreamStack, taskDisplayArea.getTopRootTask());
+ assertEquals(pinnedStack, taskDisplayArea.getRootTaskAt(topPosition - 1));
- final Task assistStack = taskDisplayArea.createStack(
+ final Task assistStack = taskDisplayArea.createRootTask(
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_ASSISTANT, true /* onTop */);
assertEquals(taskDisplayArea, assistStack.getDisplayArea());
assertFalse(assistStack.isAlwaysOnTop());
- topPosition = taskDisplayArea.getStackCount() - 1;
+ topPosition = taskDisplayArea.getRootTaskCount() - 1;
// Ensure Assistant shows as a non-always-on-top activity when config_assistantOnTopOfDream
// is false and on top of everything when true.
final boolean isAssistantOnTop = mContext.getResources()
.getBoolean(com.android.internal.R.bool.config_assistantOnTopOfDream);
- assertEquals(assistStack, taskDisplayArea.getStackAt(
+ assertEquals(assistStack, taskDisplayArea.getRootTaskAt(
isAssistantOnTop ? topPosition : topPosition - 4));
}
@@ -312,13 +312,13 @@
private void removeStackTests(Runnable runnable) {
final TaskDisplayArea taskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea();
- final Task stack1 = taskDisplayArea.createStack(WINDOWING_MODE_FULLSCREEN,
+ final Task stack1 = taskDisplayArea.createRootTask(WINDOWING_MODE_FULLSCREEN,
ACTIVITY_TYPE_STANDARD, ON_TOP);
- final Task stack2 = taskDisplayArea.createStack(WINDOWING_MODE_FULLSCREEN,
+ final Task stack2 = taskDisplayArea.createRootTask(WINDOWING_MODE_FULLSCREEN,
ACTIVITY_TYPE_STANDARD, ON_TOP);
- final Task stack3 = taskDisplayArea.createStack(WINDOWING_MODE_FULLSCREEN,
+ final Task stack3 = taskDisplayArea.createRootTask(WINDOWING_MODE_FULLSCREEN,
ACTIVITY_TYPE_STANDARD, ON_TOP);
- final Task stack4 = taskDisplayArea.createStack(WINDOWING_MODE_FULLSCREEN,
+ final Task stack4 = taskDisplayArea.createRootTask(WINDOWING_MODE_FULLSCREEN,
ACTIVITY_TYPE_STANDARD, ON_TOP);
final Task task1 = new TaskBuilder(mAtm.mTaskSupervisor).setParentTask(stack1).build();
final Task task2 = new TaskBuilder(mAtm.mTaskSupervisor).setParentTask(stack2).build();
@@ -333,7 +333,7 @@
// Removing stacks from the display while removing stacks.
doAnswer(invocation -> {
- taskDisplayArea.removeStack(stack2);
+ taskDisplayArea.removeRootTask(stack2);
return true;
}).when(mSupervisor).removeTask(eq(task2), anyBoolean(), anyBoolean(), any());
diff --git a/services/tests/wmtests/src/com/android/server/wm/ActivityRecordTests.java b/services/tests/wmtests/src/com/android/server/wm/ActivityRecordTests.java
index 2304efc..28c3184 100644
--- a/services/tests/wmtests/src/com/android/server/wm/ActivityRecordTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/ActivityRecordTests.java
@@ -155,7 +155,7 @@
final Task rootTask = activity.getRootTask();
rootTask.removeChild(task, null /*reason*/);
// parentTask should be gone on task removal.
- assertNull(mAtm.mRootWindowContainer.getStack(rootTask.mTaskId));
+ assertNull(mAtm.mRootWindowContainer.getRootTask(rootTask.mTaskId));
}
@Test
@@ -875,7 +875,7 @@
topRootableTask.moveToFront("test");
assertTrue(topRootableTask.isTopStackInDisplayArea());
assertEquals(topRootableTask, topActivityOnNonTopDisplay.getDisplayArea()
- .mPreferredTopFocusableStack);
+ .mPreferredTopFocusableRootTask);
final ActivityRecord secondaryDisplayActivity =
createActivityOnDisplay(false /* defaultDisplay */, null /* process */);
@@ -883,7 +883,7 @@
topRootableTask.moveToFront("test");
assertTrue(topRootableTask.isTopStackInDisplayArea());
assertEquals(topRootableTask,
- secondaryDisplayActivity.getDisplayArea().mPreferredTopFocusableStack);
+ secondaryDisplayActivity.getDisplayArea().mPreferredTopFocusableRootTask);
// The global top focus activity is on secondary display now.
// Finish top activity on default display and verify the next preferred top focusable stack
@@ -892,7 +892,7 @@
topActivityOnNonTopDisplay.finishIfPossible(0 /* resultCode */, null /* resultData */,
null /* resultGrants */, "test", false /* oomAdj */);
assertEquals(task, task.getTopMostTask());
- assertEquals(task, activity.getDisplayArea().mPreferredTopFocusableStack);
+ assertEquals(task, activity.getDisplayArea().mPreferredTopFocusableRootTask);
}
/**
@@ -1297,7 +1297,7 @@
@Test
public void testDestroyIfPossible() {
final ActivityRecord activity = createActivityWithTask();
- doReturn(false).when(mRootWindowContainer).resumeFocusedStacksTopActivities();
+ doReturn(false).when(mRootWindowContainer).resumeFocusedTasksTopActivities();
activity.destroyIfPossible("test");
assertEquals(DESTROYING, activity.getState());
@@ -1319,7 +1319,7 @@
homeStack.removeChild(t, "test");
}, true /* traverseTopToBottom */);
activity.finishing = true;
- doReturn(false).when(mRootWindowContainer).resumeFocusedStacksTopActivities();
+ doReturn(false).when(mRootWindowContainer).resumeFocusedTasksTopActivities();
// Try to destroy the last activity above the home stack.
activity.destroyIfPossible("test");
diff --git a/services/tests/wmtests/src/com/android/server/wm/ActivityStackTests.java b/services/tests/wmtests/src/com/android/server/wm/ActivityStackTests.java
index 8ccbb8f..8e3e668 100644
--- a/services/tests/wmtests/src/com/android/server/wm/ActivityStackTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/ActivityStackTests.java
@@ -48,7 +48,7 @@
import static com.android.server.wm.Task.TASK_VISIBILITY_INVISIBLE;
import static com.android.server.wm.Task.TASK_VISIBILITY_VISIBLE;
import static com.android.server.wm.Task.TASK_VISIBILITY_VISIBLE_BEHIND_TRANSLUCENT;
-import static com.android.server.wm.TaskDisplayArea.getStackAbove;
+import static com.android.server.wm.TaskDisplayArea.getRootTaskAbove;
import static com.android.server.wm.WindowContainer.POSITION_BOTTOM;
import static com.android.server.wm.WindowContainer.POSITION_TOP;
@@ -74,6 +74,8 @@
import androidx.test.filters.SmallTest;
+import com.android.server.wm.TaskDisplayArea.OnRootTaskOrderChangedListener;
+
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -154,7 +156,7 @@
organizer.setMoveToSecondaryOnEnter(false);
// Create primary splitscreen stack.
- final Task primarySplitScreen = mDefaultTaskDisplayArea.createStack(
+ final Task primarySplitScreen = mDefaultTaskDisplayArea.createRootTask(
WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, ACTIVITY_TYPE_STANDARD, true /* onTop */);
// Assert windowing mode.
@@ -179,7 +181,7 @@
public void testMoveToPrimarySplitScreenThenMoveToBack() {
TestSplitOrganizer organizer = new TestSplitOrganizer(mAtm);
// This time, start with a fullscreen activitystack
- final Task primarySplitScreen = mDefaultTaskDisplayArea.createStack(
+ final Task primarySplitScreen = mDefaultTaskDisplayArea.createRootTask(
WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_STANDARD, true /* onTop */);
primarySplitScreen.reparent(organizer.mPrimary, POSITION_TOP,
@@ -205,11 +207,11 @@
TestSplitOrganizer organizer = new TestSplitOrganizer(mAtm);
// Set up split-screen with primary on top and secondary containing the home task below
// another stack.
- final Task primaryTask = mDefaultTaskDisplayArea.createStack(
+ final Task primaryTask = mDefaultTaskDisplayArea.createRootTask(
WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, ACTIVITY_TYPE_STANDARD, true /* onTop */);
- final Task homeRoot = mDefaultTaskDisplayArea.getStack(
+ final Task homeRoot = mDefaultTaskDisplayArea.getRootTask(
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_HOME);
- final Task secondaryTask = mDefaultTaskDisplayArea.createStack(
+ final Task secondaryTask = mDefaultTaskDisplayArea.createRootTask(
WINDOWING_MODE_SPLIT_SCREEN_SECONDARY, ACTIVITY_TYPE_STANDARD, true /* onTop */);
mDefaultTaskDisplayArea.positionChildAt(POSITION_TOP, organizer.mPrimary,
false /* includingParents */);
@@ -257,7 +259,7 @@
@Test
public void testStackInheritsDisplayWindowingMode() {
- final Task primarySplitScreen = mDefaultTaskDisplayArea.createStack(
+ final Task primarySplitScreen = mDefaultTaskDisplayArea.createRootTask(
WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_STANDARD, true /* onTop */);
assertEquals(WINDOWING_MODE_FULLSCREEN, primarySplitScreen.getWindowingMode());
@@ -272,7 +274,7 @@
@Test
public void testStackOverridesDisplayWindowingMode() {
- final Task primarySplitScreen = mDefaultTaskDisplayArea.createStack(
+ final Task primarySplitScreen = mDefaultTaskDisplayArea.createRootTask(
WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_STANDARD, true /* onTop */);
assertEquals(WINDOWING_MODE_FULLSCREEN, primarySplitScreen.getWindowingMode());
@@ -365,7 +367,7 @@
verify(stack2).positionChildAtBottom(any(), eq(false) /* includingParents */);
// Also move display to back because there is only one stack left.
- taskDisplayArea.removeStack(stack1);
+ taskDisplayArea.removeRootTask(stack1);
stack2.moveToBack("testMoveStackToBackIncludingParent", stack2.getTopMostTask());
verify(stack2).positionChildAtBottom(any(), eq(true) /* includingParents */);
}
@@ -747,8 +749,8 @@
// Ensure that we don't move the home stack if it is already behind the top fullscreen stack
int homeStackIndex = mDefaultTaskDisplayArea.getIndexOf(homeStack);
- assertEquals(fullscreenStack, getStackAbove(homeStack));
- mDefaultTaskDisplayArea.moveStackBehindBottomMostVisibleStack(homeStack);
+ assertEquals(fullscreenStack, getRootTaskAbove(homeStack));
+ mDefaultTaskDisplayArea.moveRootTaskBehindBottomMostVisibleRootTask(homeStack);
assertEquals(homeStackIndex, mDefaultTaskDisplayArea.getIndexOf(homeStack));
}
@@ -765,8 +767,8 @@
// Ensure that we don't move the home stack if it is already behind the top fullscreen stack
int homeStackIndex = mDefaultTaskDisplayArea.getIndexOf(homeStack);
- assertEquals(fullscreenStack, getStackAbove(homeStack));
- mDefaultTaskDisplayArea.moveStackBehindBottomMostVisibleStack(homeStack);
+ assertEquals(fullscreenStack, getRootTaskAbove(homeStack));
+ mDefaultTaskDisplayArea.moveRootTaskBehindBottomMostVisibleRootTask(homeStack);
assertEquals(homeStackIndex, mDefaultTaskDisplayArea.getIndexOf(homeStack));
}
@@ -783,8 +785,8 @@
// Ensure we don't move the home stack if it is already on top
int homeStackIndex = mDefaultTaskDisplayArea.getIndexOf(homeStack);
- assertNull(getStackAbove(homeStack));
- mDefaultTaskDisplayArea.moveStackBehindBottomMostVisibleStack(homeStack);
+ assertNull(getRootTaskAbove(homeStack));
+ mDefaultTaskDisplayArea.moveRootTaskBehindBottomMostVisibleRootTask(homeStack);
assertEquals(homeStackIndex, mDefaultTaskDisplayArea.getIndexOf(homeStack));
}
@@ -807,9 +809,9 @@
// Ensure that we move the home stack behind the bottom most fullscreen stack, ignoring the
// pinned stack
- assertEquals(fullscreenStack1, getStackAbove(homeStack));
- mDefaultTaskDisplayArea.moveStackBehindBottomMostVisibleStack(homeStack);
- assertEquals(fullscreenStack2, getStackAbove(homeStack));
+ assertEquals(fullscreenStack1, getRootTaskAbove(homeStack));
+ mDefaultTaskDisplayArea.moveRootTaskBehindBottomMostVisibleRootTask(homeStack);
+ assertEquals(fullscreenStack2, getRootTaskAbove(homeStack));
}
@Test
@@ -830,9 +832,9 @@
// Ensure that we move the home stack behind the bottom most non-translucent fullscreen
// stack
- assertEquals(fullscreenStack1, getStackAbove(homeStack));
- mDefaultTaskDisplayArea.moveStackBehindBottomMostVisibleStack(homeStack);
- assertEquals(fullscreenStack1, getStackAbove(homeStack));
+ assertEquals(fullscreenStack1, getRootTaskAbove(homeStack));
+ mDefaultTaskDisplayArea.moveRootTaskBehindBottomMostVisibleRootTask(homeStack);
+ assertEquals(fullscreenStack1, getRootTaskAbove(homeStack));
}
@Test
@@ -852,7 +854,7 @@
// Ensure we don't move the home stack behind itself
int homeStackIndex = mDefaultTaskDisplayArea.getIndexOf(homeStack);
- mDefaultTaskDisplayArea.moveStackBehindStack(homeStack, homeStack);
+ mDefaultTaskDisplayArea.moveRootTaskBehindRootTask(homeStack, homeStack);
assertEquals(homeStackIndex, mDefaultTaskDisplayArea.getIndexOf(homeStack));
}
@@ -873,14 +875,14 @@
final Task homeStack = createStackForShouldBeVisibleTest(mDefaultTaskDisplayArea,
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_HOME, true /* onTop */);
- mDefaultTaskDisplayArea.moveStackBehindStack(homeStack, fullscreenStack1);
- assertEquals(fullscreenStack1, getStackAbove(homeStack));
- mDefaultTaskDisplayArea.moveStackBehindStack(homeStack, fullscreenStack2);
- assertEquals(fullscreenStack2, getStackAbove(homeStack));
- mDefaultTaskDisplayArea.moveStackBehindStack(homeStack, fullscreenStack4);
- assertEquals(fullscreenStack4, getStackAbove(homeStack));
- mDefaultTaskDisplayArea.moveStackBehindStack(homeStack, fullscreenStack2);
- assertEquals(fullscreenStack2, getStackAbove(homeStack));
+ mDefaultTaskDisplayArea.moveRootTaskBehindRootTask(homeStack, fullscreenStack1);
+ assertEquals(fullscreenStack1, getRootTaskAbove(homeStack));
+ mDefaultTaskDisplayArea.moveRootTaskBehindRootTask(homeStack, fullscreenStack2);
+ assertEquals(fullscreenStack2, getRootTaskAbove(homeStack));
+ mDefaultTaskDisplayArea.moveRootTaskBehindRootTask(homeStack, fullscreenStack4);
+ assertEquals(fullscreenStack4, getRootTaskAbove(homeStack));
+ mDefaultTaskDisplayArea.moveRootTaskBehindRootTask(homeStack, fullscreenStack2);
+ assertEquals(fullscreenStack2, getRootTaskAbove(homeStack));
}
@Test
@@ -889,7 +891,7 @@
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_HOME, true /* onTop */);
final Task pinnedStack = createStackForShouldBeVisibleTest(mDefaultTaskDisplayArea,
WINDOWING_MODE_PINNED, ACTIVITY_TYPE_STANDARD, true /* onTop */);
- assertEquals(pinnedStack, getStackAbove(homeStack));
+ assertEquals(pinnedStack, getRootTaskAbove(homeStack));
final Task alwaysOnTopStack = createStackForShouldBeVisibleTest(
mDefaultTaskDisplayArea, WINDOWING_MODE_FREEFORM, ACTIVITY_TYPE_STANDARD,
@@ -897,13 +899,13 @@
alwaysOnTopStack.setAlwaysOnTop(true);
assertTrue(alwaysOnTopStack.isAlwaysOnTop());
// Ensure (non-pinned) always on top stack is put below pinned stack.
- assertEquals(pinnedStack, getStackAbove(alwaysOnTopStack));
+ assertEquals(pinnedStack, getRootTaskAbove(alwaysOnTopStack));
final Task nonAlwaysOnTopStack = createStackForShouldBeVisibleTest(
mDefaultTaskDisplayArea, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD,
true /* onTop */);
// Ensure non always on top stack is put below always on top stacks.
- assertEquals(alwaysOnTopStack, getStackAbove(nonAlwaysOnTopStack));
+ assertEquals(alwaysOnTopStack, getRootTaskAbove(nonAlwaysOnTopStack));
final Task alwaysOnTopStack2 = createStackForShouldBeVisibleTest(
mDefaultTaskDisplayArea, WINDOWING_MODE_FREEFORM, ACTIVITY_TYPE_STANDARD,
@@ -911,21 +913,21 @@
alwaysOnTopStack2.setAlwaysOnTop(true);
assertTrue(alwaysOnTopStack2.isAlwaysOnTop());
// Ensure newly created always on top stack is placed above other all always on top stacks.
- assertEquals(pinnedStack, getStackAbove(alwaysOnTopStack2));
+ assertEquals(pinnedStack, getRootTaskAbove(alwaysOnTopStack2));
alwaysOnTopStack2.setAlwaysOnTop(false);
// Ensure, when always on top is turned off for a stack, the stack is put just below all
// other always on top stacks.
- assertEquals(alwaysOnTopStack, getStackAbove(alwaysOnTopStack2));
+ assertEquals(alwaysOnTopStack, getRootTaskAbove(alwaysOnTopStack2));
alwaysOnTopStack2.setAlwaysOnTop(true);
// Ensure always on top state changes properly when windowing mode changes.
alwaysOnTopStack2.setWindowingMode(WINDOWING_MODE_FULLSCREEN);
assertFalse(alwaysOnTopStack2.isAlwaysOnTop());
- assertEquals(alwaysOnTopStack, getStackAbove(alwaysOnTopStack2));
+ assertEquals(alwaysOnTopStack, getRootTaskAbove(alwaysOnTopStack2));
alwaysOnTopStack2.setWindowingMode(WINDOWING_MODE_FREEFORM);
assertTrue(alwaysOnTopStack2.isAlwaysOnTop());
- assertEquals(pinnedStack, getStackAbove(alwaysOnTopStack2));
+ assertEquals(pinnedStack, getRootTaskAbove(alwaysOnTopStack2));
}
@Test
@@ -980,7 +982,8 @@
int windowingMode, int activityType, boolean onTop, boolean twoLevelTask) {
final Task task;
if (activityType == ACTIVITY_TYPE_HOME) {
- task = mDefaultTaskDisplayArea.getStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_HOME);
+ task = mDefaultTaskDisplayArea.getRootTask(WINDOWING_MODE_FULLSCREEN,
+ ACTIVITY_TYPE_HOME);
mDefaultTaskDisplayArea.positionChildAt(onTop ? POSITION_TOP : POSITION_BOTTOM, task,
false /* includingParents */);
} else if (twoLevelTask) {
@@ -1224,12 +1227,12 @@
@Test
public void testStackOrderChangedOnRemoveStack() {
final Task task = new TaskBuilder(mSupervisor).build();
- StackOrderChangedListener listener = new StackOrderChangedListener();
- mDefaultTaskDisplayArea.registerStackOrderChangedListener(listener);
+ RootTaskOrderChangedListener listener = new RootTaskOrderChangedListener();
+ mDefaultTaskDisplayArea.registerRootTaskOrderChangedListener(listener);
try {
- mDefaultTaskDisplayArea.removeStack(task);
+ mDefaultTaskDisplayArea.removeRootTask(task);
} finally {
- mDefaultTaskDisplayArea.unregisterStackOrderChangedListener(listener);
+ mDefaultTaskDisplayArea.unregisterRootTaskOrderChangedListener(listener);
}
assertTrue(listener.mChanged);
}
@@ -1237,31 +1240,31 @@
@Test
public void testStackOrderChangedOnAddPositionStack() {
final Task task = new TaskBuilder(mSupervisor).build();
- mDefaultTaskDisplayArea.removeStack(task);
+ mDefaultTaskDisplayArea.removeRootTask(task);
- StackOrderChangedListener listener = new StackOrderChangedListener();
- mDefaultTaskDisplayArea.registerStackOrderChangedListener(listener);
+ RootTaskOrderChangedListener listener = new RootTaskOrderChangedListener();
+ mDefaultTaskDisplayArea.registerRootTaskOrderChangedListener(listener);
try {
task.mReparenting = true;
mDefaultTaskDisplayArea.addChild(task, 0);
} finally {
- mDefaultTaskDisplayArea.unregisterStackOrderChangedListener(listener);
+ mDefaultTaskDisplayArea.unregisterRootTaskOrderChangedListener(listener);
}
assertTrue(listener.mChanged);
}
@Test
public void testStackOrderChangedOnPositionStack() {
- StackOrderChangedListener listener = new StackOrderChangedListener();
+ RootTaskOrderChangedListener listener = new RootTaskOrderChangedListener();
try {
final Task fullscreenStack1 = createStackForShouldBeVisibleTest(
mDefaultTaskDisplayArea, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD,
true /* onTop */);
- mDefaultTaskDisplayArea.registerStackOrderChangedListener(listener);
+ mDefaultTaskDisplayArea.registerRootTaskOrderChangedListener(listener);
mDefaultTaskDisplayArea.positionChildAt(POSITION_BOTTOM, fullscreenStack1,
false /*includingParents*/);
} finally {
- mDefaultTaskDisplayArea.unregisterStackOrderChangedListener(listener);
+ mDefaultTaskDisplayArea.unregisterRootTaskOrderChangedListener(listener);
}
assertTrue(listener.mChanged);
}
@@ -1447,12 +1450,12 @@
assertEquals(expected, task.shouldSleepActivities());
}
- private static class StackOrderChangedListener
- implements TaskDisplayArea.OnStackOrderChangedListener {
+ private static class RootTaskOrderChangedListener
+ implements OnRootTaskOrderChangedListener {
public boolean mChanged = false;
@Override
- public void onStackOrderChanged(Task stack) {
+ public void onRootTaskOrderChanged(Task rootTask) {
mChanged = true;
}
}
diff --git a/services/tests/wmtests/src/com/android/server/wm/ActivityStartControllerTests.java b/services/tests/wmtests/src/com/android/server/wm/ActivityStartControllerTests.java
index c799f29..ce96771 100644
--- a/services/tests/wmtests/src/com/android/server/wm/ActivityStartControllerTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/ActivityStartControllerTests.java
@@ -33,8 +33,8 @@
import androidx.test.filters.SmallTest;
-import com.android.server.wm.ActivityTaskSupervisor.PendingActivityLaunch;
import com.android.server.wm.ActivityStarter.Factory;
+import com.android.server.wm.ActivityTaskSupervisor.PendingActivityLaunch;
import org.junit.Before;
import org.junit.Test;
@@ -77,8 +77,8 @@
.setCreateTask(true)
.build();
final int startFlags = random.nextInt();
- final Task stack = mAtm.mRootWindowContainer.getDefaultTaskDisplayArea()
- .createStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */);
+ final Task rootTask = mAtm.mRootWindowContainer.getDefaultTaskDisplayArea().createRootTask(
+ WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */);
final WindowProcessController wpc = new WindowProcessController(mAtm,
mAtm.mContext.getApplicationInfo(), "name", 12345,
UserHandle.getUserId(12345), mock(Object.class),
@@ -86,7 +86,7 @@
wpc.setThread(mock(IApplicationThread.class));
mController.addPendingActivityLaunch(
- new PendingActivityLaunch(activity, source, startFlags, stack, wpc, null));
+ new PendingActivityLaunch(activity, source, startFlags, rootTask, wpc, null));
final boolean resume = random.nextBoolean();
mController.doPendingActivityLaunches(resume);
diff --git a/services/tests/wmtests/src/com/android/server/wm/ActivityStarterTests.java b/services/tests/wmtests/src/com/android/server/wm/ActivityStarterTests.java
index 565bf8b..ef2e889 100644
--- a/services/tests/wmtests/src/com/android/server/wm/ActivityStarterTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/ActivityStarterTests.java
@@ -326,7 +326,7 @@
* Creates a {@link ActivityStarter} with default parameters and necessary mocks.
*
* @param launchFlags The intent flags to launch activity.
- * @param mockGetLaunchStack Whether to mock {@link RootWindowContainer#getLaunchStack} for
+ * @param mockGetLaunchStack Whether to mock {@link RootWindowContainer#getLaunchRootTask} for
* always launching to the testing stack. Set to false when allowing
* the activity can be launched to any stack that is decided by real
* implementation.
@@ -342,14 +342,14 @@
if (mockGetLaunchStack) {
// Instrument the stack and task used.
final Task stack = mRootWindowContainer.getDefaultTaskDisplayArea()
- .createStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD,
+ .createRootTask(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD,
true /* onTop */);
// Direct starter to use spy stack.
doReturn(stack).when(mRootWindowContainer)
- .getLaunchStack(any(), any(), any(), anyBoolean());
- doReturn(stack).when(mRootWindowContainer)
- .getLaunchStack(any(), any(), any(), anyBoolean(), any(), anyInt(), anyInt());
+ .getLaunchRootTask(any(), any(), any(), anyBoolean());
+ doReturn(stack).when(mRootWindowContainer).getLaunchRootTask(any(), any(), any(),
+ anyBoolean(), any(), anyInt(), anyInt());
}
// Set up mock package manager internal and make sure no unmocked methods are called
@@ -513,8 +513,8 @@
private void assertNoTasks(DisplayContent display) {
display.forAllTaskDisplayAreas(taskDisplayArea -> {
- for (int sNdx = taskDisplayArea.getStackCount() - 1; sNdx >= 0; --sNdx) {
- final Task stack = taskDisplayArea.getStackAt(sNdx);
+ for (int sNdx = taskDisplayArea.getRootTaskCount() - 1; sNdx >= 0; --sNdx) {
+ final Task stack = taskDisplayArea.getRootTaskAt(sNdx);
assertFalse(stack.hasChild());
}
});
@@ -806,7 +806,7 @@
new TestDisplayContent.Builder(mAtm, 1000, 1500)
.setPosition(POSITION_BOTTOM).build();
final TaskDisplayArea secondaryTaskContainer = secondaryDisplay.getDefaultTaskDisplayArea();
- final Task stack = secondaryTaskContainer.createStack(
+ final Task stack = secondaryTaskContainer.createRootTask(
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */);
// Create an activity record on the top of secondary display.
@@ -828,7 +828,7 @@
assertEquals(START_DELIVERED_TO_TOP, result);
// Ensure secondary display only creates one stack.
- verify(secondaryTaskContainer, times(1)).createStack(anyInt(), anyInt(), anyBoolean());
+ verify(secondaryTaskContainer, times(1)).createRootTask(anyInt(), anyInt(), anyBoolean());
}
/**
@@ -848,11 +848,11 @@
false /* includingParents */);
final TaskDisplayArea secondaryTaskContainer = secondaryDisplay.getDefaultTaskDisplayArea();
final ActivityRecord singleTaskActivity = createSingleTaskActivityOn(
- secondaryTaskContainer.createStack(WINDOWING_MODE_FULLSCREEN,
+ secondaryTaskContainer.createRootTask(WINDOWING_MODE_FULLSCREEN,
ACTIVITY_TYPE_STANDARD, false /* onTop */));
// Create another activity on top of the secondary display.
- final Task topStack = secondaryTaskContainer.createStack(WINDOWING_MODE_FULLSCREEN,
+ final Task topStack = secondaryTaskContainer.createRootTask(WINDOWING_MODE_FULLSCREEN,
ACTIVITY_TYPE_STANDARD, true /* onTop */);
final Task topTask = new TaskBuilder(mSupervisor).setParentTask(topStack).build();
new ActivityBuilder(mAtm).setTask(topTask).build();
@@ -870,7 +870,7 @@
assertEquals(START_TASK_TO_FRONT, result);
// Ensure secondary display only creates two stacks.
- verify(secondaryTaskContainer, times(2)).createStack(anyInt(), anyInt(), anyBoolean());
+ verify(secondaryTaskContainer, times(2)).createRootTask(anyInt(), anyInt(), anyBoolean());
// The metrics logger should receive the same result and non-null options.
verify(mActivityMetricsLogger).notifyActivityLaunched(any() /* launchingState */,
eq(result), eq(singleTaskActivity), notNull() /* options */);
@@ -938,7 +938,7 @@
// Create a secondary display at bottom.
final TestDisplayContent secondaryDisplay = addNewDisplayContentAt(POSITION_BOTTOM);
final TaskDisplayArea secondaryTaskContainer = secondaryDisplay.getDefaultTaskDisplayArea();
- secondaryTaskContainer.createStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD,
+ secondaryTaskContainer.createRootTask(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD,
true /* onTop */);
// Put an activity on default display as the top focused activity.
@@ -1053,7 +1053,7 @@
final ActivityStarter starter = prepareStarter(0 /* flags */);
starter.mStartActivity = new ActivityBuilder(mAtm).build();
final Task task = new TaskBuilder(mAtm.mTaskSupervisor)
- .setParentTask(mAtm.mRootWindowContainer.getDefaultTaskDisplayArea().createStack(
+ .setParentTask(mAtm.mRootWindowContainer.getDefaultTaskDisplayArea().createRootTask(
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */))
.setUserId(10)
.build();
@@ -1117,13 +1117,13 @@
final Task stack = spy(
mRootWindowContainer.getDefaultTaskDisplayArea()
- .createStack(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, ACTIVITY_TYPE_STANDARD,
+ .createRootTask(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, ACTIVITY_TYPE_STANDARD,
/* onTop */true));
stack.addChild(targetRecord);
doReturn(stack).when(mRootWindowContainer)
- .getLaunchStack(any(), any(), any(), anyBoolean(), any(), anyInt(), anyInt());
+ .getLaunchRootTask(any(), any(), any(), anyBoolean(), any(), anyInt(), anyInt());
starter.mStartActivity = new ActivityBuilder(mAtm).build();
diff --git a/services/tests/wmtests/src/com/android/server/wm/DisplayAreaPolicyTests.java b/services/tests/wmtests/src/com/android/server/wm/DisplayAreaPolicyTests.java
index 39bf8eb..5a47493 100644
--- a/services/tests/wmtests/src/com/android/server/wm/DisplayAreaPolicyTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/DisplayAreaPolicyTests.java
@@ -94,9 +94,9 @@
@Test
public void testTaskDisplayArea_taskPositionChanged_updatesTaskDisplayAreaPosition() {
- final Task stack1 = mTaskDisplayArea1.createStack(
+ final Task stack1 = mTaskDisplayArea1.createRootTask(
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */);
- final Task stack2 = mTaskDisplayArea2.createStack(
+ final Task stack2 = mTaskDisplayArea2.createRootTask(
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */);
// Initial order
@@ -155,11 +155,11 @@
.addDisplayAreaGroupHierarchy(new DisplayAreaPolicyBuilder.HierarchyBuilder(group2)
.setTaskDisplayAreas(Lists.newArrayList(taskDisplayArea5)))
.build(wms);
- final Task stack1 = taskDisplayArea1.createStack(
+ final Task stack1 = taskDisplayArea1.createRootTask(
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */);
- final Task stack3 = taskDisplayArea3.createStack(
+ final Task stack3 = taskDisplayArea3.createRootTask(
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */);
- final Task stack4 = taskDisplayArea4.createStack(
+ final Task stack4 = taskDisplayArea4.createRootTask(
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */);
// Initial order
diff --git a/services/tests/wmtests/src/com/android/server/wm/DisplayContentTests.java b/services/tests/wmtests/src/com/android/server/wm/DisplayContentTests.java
index d921718..6f7464a 100644
--- a/services/tests/wmtests/src/com/android/server/wm/DisplayContentTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/DisplayContentTests.java
@@ -839,12 +839,12 @@
final DisplayContent newDisplay = createNewDisplay();
final WindowState appWin = createWindow(null, TYPE_APPLICATION, mDisplayContent, "appWin");
- final Task stack = mDisplayContent.getTopStack();
+ final Task stack = mDisplayContent.getTopRootTask();
final ActivityRecord activity = stack.topRunningActivity();
doReturn(true).when(activity).shouldBeVisibleUnchecked();
final WindowState appWin1 = createWindow(null, TYPE_APPLICATION, newDisplay, "appWin1");
- final Task stack1 = newDisplay.getTopStack();
+ final Task stack1 = newDisplay.getTopRootTask();
final ActivityRecord activity1 = stack1.topRunningActivity();
doReturn(true).when(activity1).shouldBeVisibleUnchecked();
appWin.setHasSurface(true);
@@ -886,7 +886,7 @@
doReturn(true).when(freeformStack).isVisible();
freeformStack.getTopChild().setBounds(100, 100, 300, 400);
- assertTrue(dc.getDefaultTaskDisplayArea().isStackVisible(WINDOWING_MODE_FREEFORM));
+ assertTrue(dc.getDefaultTaskDisplayArea().isRootTaskVisible(WINDOWING_MODE_FREEFORM));
freeformStack.getTopNonFinishingActivity().setOrientation(SCREEN_ORIENTATION_LANDSCAPE);
stack.getTopNonFinishingActivity().setOrientation(SCREEN_ORIENTATION_PORTRAIT);
diff --git a/services/tests/wmtests/src/com/android/server/wm/LaunchParamsControllerTests.java b/services/tests/wmtests/src/com/android/server/wm/LaunchParamsControllerTests.java
index cd428e1..a99e40c 100644
--- a/services/tests/wmtests/src/com/android/server/wm/LaunchParamsControllerTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/LaunchParamsControllerTests.java
@@ -294,11 +294,11 @@
mController.registerModifier(positioner);
- doNothing().when(mRootWindowContainer).moveStackToTaskDisplayArea(anyInt(), any(),
+ doNothing().when(mRootWindowContainer).moveRootTaskToTaskDisplayArea(anyInt(), any(),
anyBoolean());
mController.layoutTask(task, null /* windowLayout */);
- verify(mRootWindowContainer, times(1)).moveStackToTaskDisplayArea(eq(task.getRootTaskId()),
- eq(preferredTaskDisplayArea), anyBoolean());
+ verify(mRootWindowContainer, times(1)).moveRootTaskToTaskDisplayArea(
+ eq(task.getRootTaskId()), eq(preferredTaskDisplayArea), anyBoolean());
}
/**
diff --git a/services/tests/wmtests/src/com/android/server/wm/LaunchParamsPersisterTests.java b/services/tests/wmtests/src/com/android/server/wm/LaunchParamsPersisterTests.java
index d701a9d..b7d8638 100644
--- a/services/tests/wmtests/src/com/android/server/wm/LaunchParamsPersisterTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/LaunchParamsPersisterTests.java
@@ -115,7 +115,7 @@
.thenReturn(mTestDisplay);
Task stack = mTestDisplay.getDefaultTaskDisplayArea()
- .createStack(TEST_WINDOWING_MODE, ACTIVITY_TYPE_STANDARD, /* onTop */ true);
+ .createRootTask(TEST_WINDOWING_MODE, ACTIVITY_TYPE_STANDARD, /* onTop */ true);
mTestTask = new TaskBuilder(mSupervisor).setComponent(TEST_COMPONENT).setParentTask(stack)
.build();
mTestTask.mUserId = TEST_USER_ID;
@@ -337,7 +337,7 @@
public void testClearsRecordsOfTheUserOnUserCleanUp() {
mTarget.saveTask(mTestTask);
- Task stack = mTestDisplay.getDefaultTaskDisplayArea().createStack(
+ Task stack = mTestDisplay.getDefaultTaskDisplayArea().createRootTask(
TEST_WINDOWING_MODE, ACTIVITY_TYPE_STANDARD, /* onTop */ true);
final Task anotherTaskOfTheSameUser = new TaskBuilder(mSupervisor)
.setComponent(ALTERNATIVE_COMPONENT)
@@ -349,7 +349,7 @@
anotherTaskOfTheSameUser.setHasBeenVisible(true);
mTarget.saveTask(anotherTaskOfTheSameUser);
- stack = mTestDisplay.getDefaultTaskDisplayArea().createStack(TEST_WINDOWING_MODE,
+ stack = mTestDisplay.getDefaultTaskDisplayArea().createRootTask(TEST_WINDOWING_MODE,
ACTIVITY_TYPE_STANDARD, /* onTop */ true);
final Task anotherTaskOfDifferentUser = new TaskBuilder(mSupervisor)
.setComponent(TEST_COMPONENT)
diff --git a/services/tests/wmtests/src/com/android/server/wm/RecentTasksTest.java b/services/tests/wmtests/src/com/android/server/wm/RecentTasksTest.java
index 7812934..4892ef3 100644
--- a/services/tests/wmtests/src/com/android/server/wm/RecentTasksTest.java
+++ b/services/tests/wmtests/src/com/android/server/wm/RecentTasksTest.java
@@ -724,7 +724,7 @@
mRecentTasks.setParameters(-1 /* min */, 3 /* max */, -1 /* ms */);
final TaskDisplayArea taskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea();
- final Task alwaysOnTopTask = taskDisplayArea.createStack(WINDOWING_MODE_MULTI_WINDOW,
+ final Task alwaysOnTopTask = taskDisplayArea.createRootTask(WINDOWING_MODE_MULTI_WINDOW,
ACTIVITY_TYPE_STANDARD, true /* onTop */);
alwaysOnTopTask.setAlwaysOnTop(true);
@@ -838,7 +838,7 @@
Task stack = mTasks.get(2).getRootTask();
stack.moveToFront("", mTasks.get(2));
- doReturn(stack).when(mAtm.mRootWindowContainer).getTopDisplayFocusedStack();
+ doReturn(stack).when(mAtm.mRootWindowContainer).getTopDisplayFocusedRootTask();
// Simulate the reset from the timeout
mRecentTasks.resetFreezeTaskListReorderingOnTimeout();
@@ -858,7 +858,7 @@
mRecentTasks.setParameters(-1 /* min */, 1 /* max */, -1 /* ms */);
final Task homeStack = mTaskContainer.getRootHomeTask();
- final Task aboveHomeStack = mTaskContainer.createStack(
+ final Task aboveHomeStack = mTaskContainer.createRootTask(
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */);
// Add a number of tasks (beyond the max) but ensure that nothing is trimmed because all
@@ -875,10 +875,10 @@
public void testBehindHomeStackTasks_expectTaskTrimmed() {
mRecentTasks.setParameters(-1 /* min */, 1 /* max */, -1 /* ms */);
- final Task behindHomeStack = mTaskContainer.createStack(
+ final Task behindHomeStack = mTaskContainer.createRootTask(
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */);
final Task homeStack = mTaskContainer.getRootHomeTask();
- final Task aboveHomeStack = mTaskContainer.createStack(
+ final Task aboveHomeStack = mTaskContainer.createRootTask(
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */);
// Add a number of tasks (beyond the max) but ensure that only the task in the stack behind
@@ -897,17 +897,17 @@
public void testOtherDisplayTasks_expectNoTrim() {
mRecentTasks.setParameters(-1 /* min */, 1 /* max */, -1 /* ms */);
- final Task homeStack = mTaskContainer.getRootHomeTask();
+ final Task homeTask = mTaskContainer.getRootHomeTask();
final DisplayContent otherDisplay = addNewDisplayContentAt(DisplayContent.POSITION_TOP);
- final Task otherDisplayStack = otherDisplay.getDefaultTaskDisplayArea()
- .createStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */);
+ final Task otherDisplayRootTask = otherDisplay.getDefaultTaskDisplayArea().createRootTask(
+ WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */);
// Add a number of tasks (beyond the max) on each display, ensure that the tasks are not
// removed
- mRecentTasks.add(createTaskBuilder(".HomeTask1").setParentTask(homeStack).build());
- mRecentTasks.add(createTaskBuilder(".Task1").setParentTask(otherDisplayStack).build());
- mRecentTasks.add(createTaskBuilder(".Task2").setParentTask(otherDisplayStack).build());
- mRecentTasks.add(createTaskBuilder(".HomeTask2").setParentTask(homeStack).build());
+ mRecentTasks.add(createTaskBuilder(".HomeTask1").setParentTask(homeTask).build());
+ mRecentTasks.add(createTaskBuilder(".Task1").setParentTask(otherDisplayRootTask).build());
+ mRecentTasks.add(createTaskBuilder(".Task2").setParentTask(otherDisplayRootTask).build());
+ mRecentTasks.add(createTaskBuilder(".HomeTask2").setParentTask(homeTask).build());
triggerTrimAndAssertNoTasksTrimmed();
}
@@ -1103,9 +1103,9 @@
private void assertNotRestoreTask(Runnable action) {
// Verify stack count doesn't change because task with fullscreen mode and standard type
// would have its own stack.
- final int originalStackCount = mTaskContainer.getStackCount();
+ final int originalStackCount = mTaskContainer.getRootTaskCount();
action.run();
- assertEquals(originalStackCount, mTaskContainer.getStackCount());
+ assertEquals(originalStackCount, mTaskContainer.getRootTaskCount());
}
@Test
diff --git a/services/tests/wmtests/src/com/android/server/wm/RecentsAnimationTest.java b/services/tests/wmtests/src/com/android/server/wm/RecentsAnimationTest.java
index 5ff3ff5..63ee5d0 100644
--- a/services/tests/wmtests/src/com/android/server/wm/RecentsAnimationTest.java
+++ b/services/tests/wmtests/src/com/android/server/wm/RecentsAnimationTest.java
@@ -89,7 +89,7 @@
@Test
public void testRecentsActivityVisiblility() {
TaskDisplayArea taskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea();
- Task recentsStack = taskDisplayArea.createStack(WINDOWING_MODE_FULLSCREEN,
+ Task recentsStack = taskDisplayArea.createRootTask(WINDOWING_MODE_FULLSCREEN,
ACTIVITY_TYPE_RECENTS, true /* onTop */);
ActivityRecord recentActivity = new ActivityBuilder(mAtm)
.setComponent(mRecentsComponent)
@@ -118,7 +118,7 @@
public void testPreloadRecentsActivity() {
TaskDisplayArea defaultTaskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea();
final Task homeStack =
- defaultTaskDisplayArea.getStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_HOME);
+ defaultTaskDisplayArea.getRootTask(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_HOME);
defaultTaskDisplayArea.positionChildAt(POSITION_TOP, homeStack,
false /* includingParents */);
ActivityRecord topRunningHomeActivity = homeStack.topRunningActivity();
@@ -150,7 +150,7 @@
mAtm.startRecentsActivity(recentsIntent, 0 /* eventTime */,
null /* recentsAnimationRunner */);
- Task recentsStack = defaultTaskDisplayArea.getStack(WINDOWING_MODE_FULLSCREEN,
+ Task recentsStack = defaultTaskDisplayArea.getRootTask(WINDOWING_MODE_FULLSCREEN,
ACTIVITY_TYPE_RECENTS);
assertThat(recentsStack).isNotNull();
@@ -179,7 +179,7 @@
public void testRestartRecentsActivity() throws Exception {
// Have a recents activity that is not attached to its process (ActivityRecord.app = null).
TaskDisplayArea defaultTaskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea();
- Task recentsStack = defaultTaskDisplayArea.createStack(WINDOWING_MODE_FULLSCREEN,
+ Task recentsStack = defaultTaskDisplayArea.createRootTask(WINDOWING_MODE_FULLSCREEN,
ACTIVITY_TYPE_RECENTS, true /* onTop */);
ActivityRecord recentActivity = new ActivityBuilder(mAtm).setComponent(
mRecentsComponent).setCreateTask(true).setParentTask(recentsStack).build();
@@ -251,21 +251,21 @@
@Test
public void testCancelAnimationOnVisibleStackOrderChange() {
TaskDisplayArea taskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea();
- Task fullscreenStack = taskDisplayArea.createStack(WINDOWING_MODE_FULLSCREEN,
+ Task fullscreenStack = taskDisplayArea.createRootTask(WINDOWING_MODE_FULLSCREEN,
ACTIVITY_TYPE_STANDARD, true /* onTop */);
new ActivityBuilder(mAtm)
.setComponent(new ComponentName(mContext.getPackageName(), "App1"))
.setCreateTask(true)
.setParentTask(fullscreenStack)
.build();
- Task recentsStack = taskDisplayArea.createStack(WINDOWING_MODE_FULLSCREEN,
+ Task recentsStack = taskDisplayArea.createRootTask(WINDOWING_MODE_FULLSCREEN,
ACTIVITY_TYPE_RECENTS, true /* onTop */);
new ActivityBuilder(mAtm)
.setComponent(mRecentsComponent)
.setCreateTask(true)
.setParentTask(recentsStack)
.build();
- Task fullscreenStack2 = taskDisplayArea.createStack(WINDOWING_MODE_FULLSCREEN,
+ Task fullscreenStack2 = taskDisplayArea.createRootTask(WINDOWING_MODE_FULLSCREEN,
ACTIVITY_TYPE_STANDARD, true /* onTop */);
new ActivityBuilder(mAtm)
.setComponent(new ComponentName(mContext.getPackageName(), "App2"))
@@ -292,21 +292,21 @@
@Test
public void testKeepAnimationOnHiddenStackOrderChange() {
TaskDisplayArea taskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea();
- Task fullscreenStack = taskDisplayArea.createStack(WINDOWING_MODE_FULLSCREEN,
+ Task fullscreenStack = taskDisplayArea.createRootTask(WINDOWING_MODE_FULLSCREEN,
ACTIVITY_TYPE_STANDARD, true /* onTop */);
new ActivityBuilder(mAtm)
.setComponent(new ComponentName(mContext.getPackageName(), "App1"))
.setCreateTask(true)
.setParentTask(fullscreenStack)
.build();
- Task recentsStack = taskDisplayArea.createStack(WINDOWING_MODE_FULLSCREEN,
+ Task recentsStack = taskDisplayArea.createRootTask(WINDOWING_MODE_FULLSCREEN,
ACTIVITY_TYPE_RECENTS, true /* onTop */);
new ActivityBuilder(mAtm)
.setComponent(mRecentsComponent)
.setCreateTask(true)
.setParentTask(recentsStack)
.build();
- Task fullscreenStack2 = taskDisplayArea.createStack(WINDOWING_MODE_FULLSCREEN,
+ Task fullscreenStack2 = taskDisplayArea.createRootTask(WINDOWING_MODE_FULLSCREEN,
ACTIVITY_TYPE_STANDARD, true /* onTop */);
new ActivityBuilder(mAtm)
.setComponent(new ComponentName(mContext.getPackageName(), "App2"))
@@ -329,7 +329,7 @@
public void testMultipleUserHomeActivity_findUserHomeTask() {
TaskDisplayArea taskDisplayArea = mRootWindowContainer.getDefaultDisplay()
.getDefaultTaskDisplayArea();
- Task homeStack = taskDisplayArea.getStack(WINDOWING_MODE_UNDEFINED,
+ Task homeStack = taskDisplayArea.getRootTask(WINDOWING_MODE_UNDEFINED,
ACTIVITY_TYPE_HOME);
ActivityRecord otherUserHomeActivity = new ActivityBuilder(mAtm)
.setParentTask(homeStack)
@@ -338,7 +338,7 @@
.build();
otherUserHomeActivity.getTask().mUserId = TEST_USER_ID;
- Task fullscreenStack = taskDisplayArea.createStack(WINDOWING_MODE_FULLSCREEN,
+ Task fullscreenStack = taskDisplayArea.createRootTask(WINDOWING_MODE_FULLSCREEN,
ACTIVITY_TYPE_STANDARD, true /* onTop */);
new ActivityBuilder(mAtm)
.setComponent(new ComponentName(mContext.getPackageName(), "App1"))
diff --git a/services/tests/wmtests/src/com/android/server/wm/RootActivityContainerTests.java b/services/tests/wmtests/src/com/android/server/wm/RootActivityContainerTests.java
index 7ca364cf..f79e4cc 100644
--- a/services/tests/wmtests/src/com/android/server/wm/RootActivityContainerTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/RootActivityContainerTests.java
@@ -94,7 +94,7 @@
@Before
public void setUp() throws Exception {
- mFullscreenStack = mRootWindowContainer.getDefaultTaskDisplayArea().createStack(
+ mFullscreenStack = mRootWindowContainer.getDefaultTaskDisplayArea().createRootTask(
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */);
doNothing().when(mAtm).updateSleepIfNeededLocked();
}
@@ -128,7 +128,7 @@
ensureStackPlacement(mFullscreenStack, firstActivity, secondActivity);
// Move first activity to pinned stack.
- mRootWindowContainer.moveActivityToPinnedStack(firstActivity, "initialMove");
+ mRootWindowContainer.moveActivityToPinnedRootTask(firstActivity, "initialMove");
final TaskDisplayArea taskDisplayArea = mFullscreenStack.getDisplayArea();
Task pinnedStack = taskDisplayArea.getRootPinnedTask();
@@ -137,11 +137,11 @@
ensureStackPlacement(mFullscreenStack, secondActivity);
// Move second activity to pinned stack.
- mRootWindowContainer.moveActivityToPinnedStack(secondActivity, "secondMove");
+ mRootWindowContainer.moveActivityToPinnedRootTask(secondActivity, "secondMove");
// Need to get stacks again as a new instance might have been created.
pinnedStack = taskDisplayArea.getRootPinnedTask();
- mFullscreenStack = taskDisplayArea.getStack(WINDOWING_MODE_FULLSCREEN,
+ mFullscreenStack = taskDisplayArea.getRootTask(WINDOWING_MODE_FULLSCREEN,
ACTIVITY_TYPE_STANDARD);
// Ensure stacks have swapped tasks.
ensureStackPlacement(pinnedStack, secondActivity);
@@ -166,7 +166,7 @@
// Move first activity to pinned stack.
- mRootWindowContainer.moveActivityToPinnedStack(secondActivity, "initialMove");
+ mRootWindowContainer.moveActivityToPinnedRootTask(secondActivity, "initialMove");
assertTrue(firstActivity.mRequestForceTransition);
}
@@ -237,9 +237,9 @@
doReturn(keyguardShowing).when(keyguard).isKeyguardOrAodShowing(anyInt());
doReturn(isFocusedStack).when(stack).isFocusedStackOnDisplay();
- doReturn(isFocusedStack ? stack : null).when(display).getFocusedStack();
+ doReturn(isFocusedStack ? stack : null).when(display).getFocusedRootTask();
TaskDisplayArea defaultTaskDisplayArea = display.getDefaultTaskDisplayArea();
- doReturn(isFocusedStack ? stack : null).when(defaultTaskDisplayArea).getFocusedStack();
+ doReturn(isFocusedStack ? stack : null).when(defaultTaskDisplayArea).getFocusedRootTask();
mRootWindowContainer.applySleepTokens(true);
verify(stack, times(expectWakeFromSleep ? 1 : 0)).awakeFromSleepingLocked();
verify(stack, times(expectResumeTopActivity ? 1 : 0)).resumeTopActivityUncheckedLocked(
@@ -282,19 +282,19 @@
public void testRemovingStackOnAppCrash() {
final TaskDisplayArea defaultTaskDisplayArea = mRootWindowContainer
.getDefaultTaskDisplayArea();
- final int originalStackCount = defaultTaskDisplayArea.getStackCount();
- final Task stack = defaultTaskDisplayArea.createStack(
+ final int originalStackCount = defaultTaskDisplayArea.getRootTaskCount();
+ final Task stack = defaultTaskDisplayArea.createRootTask(
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, false /* onTop */);
final ActivityRecord firstActivity = new ActivityBuilder(mAtm).setTask(stack).build();
- assertEquals(originalStackCount + 1, defaultTaskDisplayArea.getStackCount());
+ assertEquals(originalStackCount + 1, defaultTaskDisplayArea.getRootTaskCount());
// Let's pretend that the app has crashed.
firstActivity.app.setThread(null);
mRootWindowContainer.finishTopCrashedActivities(firstActivity.app, "test");
// Verify that the stack was removed.
- assertEquals(originalStackCount, defaultTaskDisplayArea.getStackCount());
+ assertEquals(originalStackCount, defaultTaskDisplayArea.getRootTaskCount());
}
/**
@@ -305,34 +305,34 @@
public void testRemovingStackOnAppCrash_multipleDisplayAreas() {
final TaskDisplayArea defaultTaskDisplayArea = mRootWindowContainer
.getDefaultTaskDisplayArea();
- final int originalStackCount = defaultTaskDisplayArea.getStackCount();
- final Task stack = defaultTaskDisplayArea.createStack(
+ final int originalStackCount = defaultTaskDisplayArea.getRootTaskCount();
+ final Task stack = defaultTaskDisplayArea.createRootTask(
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, false /* onTop */);
final ActivityRecord firstActivity = new ActivityBuilder(mAtm).setTask(stack).build();
- assertEquals(originalStackCount + 1, defaultTaskDisplayArea.getStackCount());
+ assertEquals(originalStackCount + 1, defaultTaskDisplayArea.getRootTaskCount());
final DisplayContent dc = defaultTaskDisplayArea.getDisplayContent();
final TaskDisplayArea secondTaskDisplayArea = createTaskDisplayArea(
dc, mRootWindowContainer.mWmService, "TestTaskDisplayArea", FEATURE_VENDOR_FIRST);
- final Task secondStack = secondTaskDisplayArea.createStack(
+ final Task secondStack = secondTaskDisplayArea.createRootTask(
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, false /* onTop */);
new ActivityBuilder(mAtm).setTask(secondStack).setUseProcess(firstActivity.app).build();
- assertEquals(1, secondTaskDisplayArea.getStackCount());
+ assertEquals(1, secondTaskDisplayArea.getRootTaskCount());
// Let's pretend that the app has crashed.
firstActivity.app.setThread(null);
mRootWindowContainer.finishTopCrashedActivities(firstActivity.app, "test");
// Verify that the stacks were removed.
- assertEquals(originalStackCount, defaultTaskDisplayArea.getStackCount());
- assertEquals(0, secondTaskDisplayArea.getStackCount());
+ assertEquals(originalStackCount, defaultTaskDisplayArea.getRootTaskCount());
+ assertEquals(0, secondTaskDisplayArea.getRootTaskCount());
}
@Test
public void testFocusability() {
final TaskDisplayArea defaultTaskDisplayArea = mRootWindowContainer
.getDefaultTaskDisplayArea();
- final Task stack = defaultTaskDisplayArea.createStack(
+ final Task stack = defaultTaskDisplayArea.createRootTask(
WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, ACTIVITY_TYPE_STANDARD, true /* onTop */);
final ActivityRecord activity = new ActivityBuilder(mAtm).setTask(stack).build();
@@ -345,7 +345,7 @@
assertFalse(stack.isTopActivityFocusable());
assertFalse(activity.isFocusable());
- final Task pinnedStack = defaultTaskDisplayArea.createStack(
+ final Task pinnedStack = defaultTaskDisplayArea.createRootTask(
WINDOWING_MODE_PINNED, ACTIVITY_TYPE_STANDARD, true /* onTop */);
final ActivityRecord pinnedActivity = new ActivityBuilder(mAtm)
.setTask(pinnedStack).build();
@@ -371,7 +371,7 @@
public void testSplitScreenPrimaryChosenWhenTopActivityLaunchedToSecondary() {
// Create primary split-screen stack with a task and an activity.
final Task primaryStack = mRootWindowContainer.getDefaultTaskDisplayArea()
- .createStack(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, ACTIVITY_TYPE_STANDARD,
+ .createRootTask(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, ACTIVITY_TYPE_STANDARD,
true /* onTop */);
final Task task = new TaskBuilder(mSupervisor).setParentTask(primaryStack).build();
final ActivityRecord r = new ActivityBuilder(mAtm).setTask(task).build();
@@ -381,7 +381,7 @@
final ActivityOptions options = ActivityOptions.makeBasic();
options.setLaunchWindowingMode(WINDOWING_MODE_FULLSCREEN_OR_SPLIT_SCREEN_SECONDARY);
final Task result =
- mRootWindowContainer.getLaunchStack(r, options, task, true /* onTop */);
+ mRootWindowContainer.getLaunchRootTask(r, options, task, true /* onTop */);
// Assert that the primary stack is returned.
assertEquals(primaryStack, result);
@@ -410,7 +410,7 @@
false);
final TaskDisplayArea taskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea();
- verify(taskDisplayArea).moveHomeStackToFront(contains(reason));
+ verify(taskDisplayArea).moveHomeRootTaskToFront(contains(reason));
}
/**
@@ -421,7 +421,7 @@
public void testFindTaskToMoveToFrontWhenRecentsOnOtherDisplay() {
// Create stack/task on default display.
final TaskDisplayArea taskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea();
- final Task targetStack = taskDisplayArea.createStack(WINDOWING_MODE_FULLSCREEN,
+ final Task targetStack = taskDisplayArea.createRootTask(WINDOWING_MODE_FULLSCREEN,
ACTIVITY_TYPE_STANDARD, false /* onTop */);
final Task targetTask = new TaskBuilder(mSupervisor).setParentTask(targetStack).build();
@@ -429,7 +429,7 @@
final TestDisplayContent secondDisplay = addNewDisplayContentAt(
DisplayContent.POSITION_TOP);
final Task stack = secondDisplay.getDefaultTaskDisplayArea()
- .createStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_RECENTS, true /* onTop */);
+ .createRootTask(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_RECENTS, true /* onTop */);
final Task task = new TaskBuilder(mSupervisor).setParentTask(stack).build();
new ActivityBuilder(mAtm).setTask(task).build();
@@ -437,7 +437,7 @@
mSupervisor.findTaskToMoveToFront(targetTask, 0, ActivityOptions.makeBasic(), reason,
false);
- verify(taskDisplayArea, never()).moveHomeStackToFront(contains(reason));
+ verify(taskDisplayArea, never()).moveHomeRootTaskToFront(contains(reason));
}
/**
@@ -448,7 +448,7 @@
public void testResumeActivityWhenNonTopmostStackIsTopFocused() {
// Create a stack at bottom.
final TaskDisplayArea taskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea();
- final Task targetStack = spy(taskDisplayArea.createStack(WINDOWING_MODE_FULLSCREEN,
+ final Task targetStack = spy(taskDisplayArea.createRootTask(WINDOWING_MODE_FULLSCREEN,
ACTIVITY_TYPE_STANDARD, false /* onTop */));
final Task task = new TaskBuilder(mSupervisor).setParentTask(targetStack).build();
final ActivityRecord activity = new ActivityBuilder(mAtm).setTask(task).build();
@@ -457,10 +457,10 @@
// Assume the stack is not at the topmost position (e.g. behind always-on-top stacks) but it
// is the current top focused stack.
assertFalse(targetStack.isTopStackInDisplayArea());
- doReturn(targetStack).when(mRootWindowContainer).getTopDisplayFocusedStack();
+ doReturn(targetStack).when(mRootWindowContainer).getTopDisplayFocusedRootTask();
// Use the stack as target to resume.
- mRootWindowContainer.resumeFocusedStacksTopActivities(
+ mRootWindowContainer.resumeFocusedTasksTopActivities(
targetStack, activity, null /* targetOptions */);
// Verify the target stack should resume its activity.
@@ -477,14 +477,14 @@
mFullscreenStack.removeIfPossible();
final TaskDisplayArea taskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea();
taskDisplayArea.getRootHomeTask().removeIfPossible();
- taskDisplayArea.createStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_HOME, ON_TOP);
+ taskDisplayArea.createRootTask(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_HOME, ON_TOP);
doReturn(true).when(mRootWindowContainer).resumeHomeActivity(any(), any(), any());
mAtm.setBooted(true);
// Trigger resume on all displays
- mRootWindowContainer.resumeFocusedStacksTopActivities();
+ mRootWindowContainer.resumeFocusedTasksTopActivities();
// Verify that home activity was started on the default display
verify(mRootWindowContainer).resumeHomeActivity(any(), any(), eq(taskDisplayArea));
@@ -499,14 +499,14 @@
mFullscreenStack.removeIfPossible();
final TaskDisplayArea taskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea();
taskDisplayArea.getRootHomeTask().removeIfPossible();
- taskDisplayArea.createStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_HOME, ON_TOP);
+ taskDisplayArea.createRootTask(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_HOME, ON_TOP);
// Create an activity on secondary display.
final TestDisplayContent secondDisplay = addNewDisplayContentAt(
DisplayContent.POSITION_TOP);
- final Task stack = secondDisplay.getDefaultTaskDisplayArea()
- .createStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */);
- final Task task = new TaskBuilder(mSupervisor).setParentTask(stack).build();
+ final Task rootTask = secondDisplay.getDefaultTaskDisplayArea().createRootTask(
+ WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */);
+ final Task task = new TaskBuilder(mSupervisor).setParentTask(rootTask).build();
new ActivityBuilder(mAtm).setTask(task).build();
doReturn(true).when(mRootWindowContainer).resumeHomeActivity(any(), any(), any());
@@ -514,7 +514,7 @@
mAtm.setBooted(true);
// Trigger resume on all displays
- mRootWindowContainer.resumeFocusedStacksTopActivities();
+ mRootWindowContainer.resumeFocusedTasksTopActivities();
// Verify that home activity was started on the default display
verify(mRootWindowContainer).resumeHomeActivity(any(), any(), eq(taskDisplayArea));
@@ -528,7 +528,7 @@
public void testResumeActivityLingeringTransition() {
// Create a stack at top.
final TaskDisplayArea taskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea();
- final Task targetStack = spy(taskDisplayArea.createStack(WINDOWING_MODE_FULLSCREEN,
+ final Task targetStack = spy(taskDisplayArea.createRootTask(WINDOWING_MODE_FULLSCREEN,
ACTIVITY_TYPE_STANDARD, false /* onTop */));
final Task task = new TaskBuilder(mSupervisor).setParentTask(targetStack).build();
final ActivityRecord activity = new ActivityBuilder(mAtm).setTask(task).build();
@@ -538,7 +538,7 @@
assertTrue(targetStack.isTopStackInDisplayArea());
// Use the stack as target to resume.
- mRootWindowContainer.resumeFocusedStacksTopActivities();
+ mRootWindowContainer.resumeFocusedTasksTopActivities();
// Verify the lingering app transition is being executed because it's already resumed
verify(targetStack, times(1)).executeAppTransition(any());
@@ -548,7 +548,7 @@
public void testResumeActivityLingeringTransition_notExecuted() {
// Create a stack at bottom.
final TaskDisplayArea taskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea();
- final Task targetStack = spy(taskDisplayArea.createStack(WINDOWING_MODE_FULLSCREEN,
+ final Task targetStack = spy(taskDisplayArea.createRootTask(WINDOWING_MODE_FULLSCREEN,
ACTIVITY_TYPE_STANDARD, false /* onTop */));
final Task task = new TaskBuilder(mSupervisor).setParentTask(targetStack).build();
final ActivityRecord activity = new ActivityBuilder(mAtm).setTask(task).build();
@@ -557,10 +557,10 @@
// Assume the stack is at the topmost position
assertFalse(targetStack.isTopStackInDisplayArea());
- doReturn(targetStack).when(mRootWindowContainer).getTopDisplayFocusedStack();
+ doReturn(targetStack).when(mRootWindowContainer).getTopDisplayFocusedRootTask();
// Use the stack as target to resume.
- mRootWindowContainer.resumeFocusedStacksTopActivities();
+ mRootWindowContainer.resumeFocusedTasksTopActivities();
// Verify the lingering app transition is being executed because it's already resumed
verify(targetStack, never()).executeAppTransition(any());
@@ -586,9 +586,9 @@
mRootWindowContainer.startHomeOnAllDisplays(0, "testStartHome");
- assertTrue(mRootWindowContainer.getDefaultDisplay().getTopStack().isActivityTypeHome());
- assertNotNull(secondDisplay.getTopStack());
- assertTrue(secondDisplay.getTopStack().isActivityTypeHome());
+ assertTrue(mRootWindowContainer.getDefaultDisplay().getTopRootTask().isActivityTypeHome());
+ assertNotNull(secondDisplay.getTopRootTask());
+ assertTrue(secondDisplay.getTopRootTask().isActivityTypeHome());
}
/**
@@ -840,7 +840,7 @@
}
/**
- * Test that {@link RootWindowContainer#getLaunchStack} with the real caller id will get the
+ * Test that {@link RootWindowContainer#getLaunchRootTask} with the real caller id will get the
* expected stack when requesting the activity launch on the secondary display.
*/
@Test
@@ -861,7 +861,7 @@
options.setLaunchWindowingMode(WINDOWING_MODE_FULLSCREEN);
doReturn(true).when(mSupervisor).canPlaceEntityOnDisplay(secondaryDisplay.mDisplayId,
300 /* test realCallerPid */, 300 /* test realCallerUid */, r.info);
- final Task result = mRootWindowContainer.getLaunchStack(r, options,
+ final Task result = mRootWindowContainer.getLaunchRootTask(r, options,
null /* task */, true /* onTop */, null, 300 /* test realCallerPid */,
300 /* test realCallerUid */);
@@ -881,7 +881,7 @@
final ActivityRecord activity = new ActivityBuilder(mAtm).setTask(task).build();
// Make sure the root task is valid and can be reused on default display.
- final Task stack = mRootWindowContainer.getValidLaunchStackInTaskDisplayArea(
+ final Task stack = mRootWindowContainer.getValidLaunchRootTaskInTaskDisplayArea(
mRootWindowContainer.getDefaultTaskDisplayArea(), activity, task,
null /* options */, null /* launchParams */);
assertEquals(task, stack);
@@ -889,7 +889,7 @@
@Test
public void testSwitchUser_missingHomeRootTask() {
- doReturn(mFullscreenStack).when(mRootWindowContainer).getTopDisplayFocusedStack();
+ doReturn(mFullscreenStack).when(mRootWindowContainer).getTopDisplayFocusedRootTask();
final TaskDisplayArea taskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea();
Task homeStack = taskDisplayArea.getRootHomeTask();
@@ -904,7 +904,7 @@
mRootWindowContainer.switchUser(otherUser, null);
assertNotNull(taskDisplayArea.getRootHomeTask());
- assertEquals(taskDisplayArea.getTopStack(), taskDisplayArea.getRootHomeTask());
+ assertEquals(taskDisplayArea.getTopRootTask(), taskDisplayArea.getRootHomeTask());
}
/**
diff --git a/services/tests/wmtests/src/com/android/server/wm/RootWindowContainerTests.java b/services/tests/wmtests/src/com/android/server/wm/RootWindowContainerTests.java
index 42193c8..9af2b96 100644
--- a/services/tests/wmtests/src/com/android/server/wm/RootWindowContainerTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/RootWindowContainerTests.java
@@ -92,7 +92,7 @@
public void testAllPausedActivitiesComplete() {
DisplayContent displayContent = mWm.mRoot.getDisplayContent(DEFAULT_DISPLAY);
TaskDisplayArea taskDisplayArea = displayContent.getDefaultTaskDisplayArea();
- Task stack = taskDisplayArea.getStackAt(0);
+ Task stack = taskDisplayArea.getRootTaskAt(0);
ActivityRecord activity = createActivityRecord(displayContent);
stack.mPausingActivity = activity;
diff --git a/services/tests/wmtests/src/com/android/server/wm/RunningTasksTest.java b/services/tests/wmtests/src/com/android/server/wm/RunningTasksTest.java
index 95e344d..6821d47 100644
--- a/services/tests/wmtests/src/com/android/server/wm/RunningTasksTest.java
+++ b/services/tests/wmtests/src/com/android/server/wm/RunningTasksTest.java
@@ -71,7 +71,7 @@
final int numTasks = 10;
int activeTime = 0;
for (int i = 0; i < numTasks; i++) {
- createTask(display.getDefaultTaskDisplayArea().getStackAt(i % numStacks),
+ createTask(display.getDefaultTaskDisplayArea().getRootTaskAt(i % numStacks),
".Task" + i, i, activeTime++, null);
}
diff --git a/services/tests/wmtests/src/com/android/server/wm/SystemServicesTestRule.java b/services/tests/wmtests/src/com/android/server/wm/SystemServicesTestRule.java
index 2db736e6..536ef48 100644
--- a/services/tests/wmtests/src/com/android/server/wm/SystemServicesTestRule.java
+++ b/services/tests/wmtests/src/com/android/server/wm/SystemServicesTestRule.java
@@ -326,7 +326,7 @@
// Set the default focused TDA.
display.setLastFocusedTaskDisplayArea(taskDisplayArea);
spyOn(taskDisplayArea);
- final Task homeStack = taskDisplayArea.getStack(
+ final Task homeStack = taskDisplayArea.getRootTask(
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_HOME);
spyOn(homeStack);
}
diff --git a/services/tests/wmtests/src/com/android/server/wm/TaskDisplayAreaTests.java b/services/tests/wmtests/src/com/android/server/wm/TaskDisplayAreaTests.java
index 28ba710..d80f816 100644
--- a/services/tests/wmtests/src/com/android/server/wm/TaskDisplayAreaTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/TaskDisplayAreaTests.java
@@ -181,33 +181,33 @@
final Task newStack = createTaskStackOnDisplay(WINDOWING_MODE_FULLSCREEN,
ACTIVITY_TYPE_STANDARD, mDisplayContent);
final TaskDisplayArea taskDisplayArea = candidateTask.getDisplayArea();
- doReturn(newStack).when(taskDisplayArea).createStack(anyInt(), anyInt(), anyBoolean(),
+ doReturn(newStack).when(taskDisplayArea).createRootTask(anyInt(), anyInt(), anyBoolean(),
any(), any(), anyBoolean());
final int type = ACTIVITY_TYPE_STANDARD;
- assertGetOrCreateStack(WINDOWING_MODE_FULLSCREEN, type, candidateTask,
+ assertGetOrCreateRootTask(WINDOWING_MODE_FULLSCREEN, type, candidateTask,
true /* reuseCandidate */);
- assertGetOrCreateStack(WINDOWING_MODE_UNDEFINED, type, candidateTask,
+ assertGetOrCreateRootTask(WINDOWING_MODE_UNDEFINED, type, candidateTask,
true /* reuseCandidate */);
- assertGetOrCreateStack(WINDOWING_MODE_SPLIT_SCREEN_SECONDARY, type, candidateTask,
+ assertGetOrCreateRootTask(WINDOWING_MODE_SPLIT_SCREEN_SECONDARY, type, candidateTask,
true /* reuseCandidate */);
- assertGetOrCreateStack(WINDOWING_MODE_FREEFORM, type, candidateTask,
+ assertGetOrCreateRootTask(WINDOWING_MODE_FREEFORM, type, candidateTask,
true /* reuseCandidate */);
- assertGetOrCreateStack(WINDOWING_MODE_MULTI_WINDOW, type, candidateTask,
+ assertGetOrCreateRootTask(WINDOWING_MODE_MULTI_WINDOW, type, candidateTask,
true /* reuseCandidate */);
- assertGetOrCreateStack(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, type, candidateTask,
+ assertGetOrCreateRootTask(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, type, candidateTask,
false /* reuseCandidate */);
- assertGetOrCreateStack(WINDOWING_MODE_PINNED, type, candidateTask,
+ assertGetOrCreateRootTask(WINDOWING_MODE_PINNED, type, candidateTask,
true /* reuseCandidate */);
final int windowingMode = WINDOWING_MODE_FULLSCREEN;
- assertGetOrCreateStack(windowingMode, ACTIVITY_TYPE_HOME, candidateTask,
+ assertGetOrCreateRootTask(windowingMode, ACTIVITY_TYPE_HOME, candidateTask,
false /* reuseCandidate */);
- assertGetOrCreateStack(windowingMode, ACTIVITY_TYPE_RECENTS, candidateTask,
+ assertGetOrCreateRootTask(windowingMode, ACTIVITY_TYPE_RECENTS, candidateTask,
false /* reuseCandidate */);
- assertGetOrCreateStack(windowingMode, ACTIVITY_TYPE_ASSISTANT, candidateTask,
+ assertGetOrCreateRootTask(windowingMode, ACTIVITY_TYPE_ASSISTANT, candidateTask,
false /* reuseCandidate */);
- assertGetOrCreateStack(windowingMode, ACTIVITY_TYPE_DREAM, candidateTask,
+ assertGetOrCreateRootTask(windowingMode, ACTIVITY_TYPE_DREAM, candidateTask,
false /* reuseCandidate */);
}
@@ -250,9 +250,9 @@
final TaskDisplayArea secondTaskDisplayArea = createTaskDisplayArea(
mDisplayContent, mRootWindowContainer.mWmService, "TestTaskDisplayArea",
FEATURE_VENDOR_FIRST);
- final Task firstStack = firstTaskDisplayArea.createStack(
+ final Task firstStack = firstTaskDisplayArea.createRootTask(
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, false /* onTop */);
- final Task secondStack = secondTaskDisplayArea.createStack(
+ final Task secondStack = secondTaskDisplayArea.createRootTask(
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, false /* onTop */);
final ActivityRecord firstActivity = new ActivityBuilder(mAtm)
.setTask(firstStack).build();
@@ -281,7 +281,7 @@
@Test
public void testIgnoreOrientationRequest() {
final TaskDisplayArea taskDisplayArea = mDisplayContent.getDefaultTaskDisplayArea();
- final Task stack = taskDisplayArea.createStack(
+ final Task stack = taskDisplayArea.createRootTask(
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, false /* onTop */);
final ActivityRecord activity = new ActivityBuilder(mAtm).setTask(stack).build();
@@ -326,10 +326,10 @@
assertFalse(defaultTaskDisplayArea.mChildren.contains(task));
}
- private void assertGetOrCreateStack(int windowingMode, int activityType, Task candidateTask,
+ private void assertGetOrCreateRootTask(int windowingMode, int activityType, Task candidateTask,
boolean reuseCandidate) {
final TaskDisplayArea taskDisplayArea = candidateTask.getDisplayArea();
- final Task stack = taskDisplayArea.getOrCreateStack(windowingMode, activityType,
+ final Task stack = taskDisplayArea.getOrCreateRootTask(windowingMode, activityType,
false /* onTop */, null /* intent */, candidateTask /* candidateTask */);
assertEquals(reuseCandidate, stack == candidateTask);
}
diff --git a/services/tests/wmtests/src/com/android/server/wm/TaskLaunchParamsModifierTests.java b/services/tests/wmtests/src/com/android/server/wm/TaskLaunchParamsModifierTests.java
index 4f55322..269ce5d 100644
--- a/services/tests/wmtests/src/com/android/server/wm/TaskLaunchParamsModifierTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/TaskLaunchParamsModifierTests.java
@@ -1566,13 +1566,13 @@
private ActivityRecord createSourceActivity(TestDisplayContent display) {
final Task stack = display.getDefaultTaskDisplayArea()
- .createStack(display.getWindowingMode(), ACTIVITY_TYPE_STANDARD, true);
+ .createRootTask(display.getWindowingMode(), ACTIVITY_TYPE_STANDARD, true);
return new ActivityBuilder(mAtm).setTask(stack).build();
}
private void addFreeformTaskTo(TestDisplayContent display, Rect bounds) {
final Task stack = display.getDefaultTaskDisplayArea()
- .createStack(display.getWindowingMode(), ACTIVITY_TYPE_STANDARD, true);
+ .createRootTask(display.getWindowingMode(), ACTIVITY_TYPE_STANDARD, true);
stack.setWindowingMode(WINDOWING_MODE_FREEFORM);
final Task task = new TaskBuilder(mSupervisor).setParentTask(stack).build();
// Just work around the unnecessary adjustments for bounds.
diff --git a/services/tests/wmtests/src/com/android/server/wm/TaskRecordTests.java b/services/tests/wmtests/src/com/android/server/wm/TaskRecordTests.java
index 61d4a47..4a5ff58 100644
--- a/services/tests/wmtests/src/com/android/server/wm/TaskRecordTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/TaskRecordTests.java
@@ -177,7 +177,7 @@
public void testFitWithinBounds() {
final Rect parentBounds = new Rect(10, 10, 200, 200);
TaskDisplayArea taskDisplayArea = mAtm.mRootWindowContainer.getDefaultTaskDisplayArea();
- Task stack = taskDisplayArea.createStack(WINDOWING_MODE_FREEFORM,
+ Task stack = taskDisplayArea.createRootTask(WINDOWING_MODE_FREEFORM,
ACTIVITY_TYPE_STANDARD, true /* onTop */);
Task task = new TaskBuilder(mSupervisor).setParentTask(stack).build();
final Configuration parentConfig = stack.getConfiguration();
@@ -497,7 +497,7 @@
@Test
public void testInsetDisregardedWhenFreeformOverlapsNavBar() {
TaskDisplayArea taskDisplayArea = mAtm.mRootWindowContainer.getDefaultTaskDisplayArea();
- Task stack = taskDisplayArea.createStack(WINDOWING_MODE_FULLSCREEN,
+ Task stack = taskDisplayArea.createRootTask(WINDOWING_MODE_FULLSCREEN,
ACTIVITY_TYPE_STANDARD, true /* onTop */);
DisplayInfo displayInfo = new DisplayInfo();
mAtm.mContext.getDisplay().getDisplayInfo(displayInfo);
@@ -1027,9 +1027,9 @@
final TaskDisplayArea secondTaskDisplayArea = createTaskDisplayArea(
mDisplayContent, mRootWindowContainer.mWmService, "TestTaskDisplayArea",
FEATURE_VENDOR_FIRST);
- final Task firstStack = firstTaskDisplayArea.createStack(
+ final Task firstStack = firstTaskDisplayArea.createRootTask(
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, false /* onTop */);
- final Task secondStack = secondTaskDisplayArea.createStack(
+ final Task secondStack = secondTaskDisplayArea.createRootTask(
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, false /* onTop */);
final ActivityRecord firstActivity = new ActivityBuilder(mAtm)
.setTask(firstStack).build();
@@ -1083,7 +1083,7 @@
Rect expectedConfigBounds) {
TaskDisplayArea taskDisplayArea = mAtm.mRootWindowContainer.getDefaultTaskDisplayArea();
- Task stack = taskDisplayArea.createStack(windowingMode, ACTIVITY_TYPE_STANDARD,
+ Task stack = taskDisplayArea.createRootTask(windowingMode, ACTIVITY_TYPE_STANDARD,
true /* onTop */);
Task task = new TaskBuilder(mSupervisor).setParentTask(stack).build();
diff --git a/services/tests/wmtests/src/com/android/server/wm/WindowContainerTests.java b/services/tests/wmtests/src/com/android/server/wm/WindowContainerTests.java
index 573da89..c4bcfdb 100644
--- a/services/tests/wmtests/src/com/android/server/wm/WindowContainerTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/WindowContainerTests.java
@@ -812,7 +812,7 @@
final ActivityRecord activity = createActivityRecord(mDisplayContent, task);
final DisplayContent newDc = createNewDisplay();
- stack.getDisplayArea().removeStack(stack);
+ stack.getDisplayArea().removeRootTask(stack);
newDc.getDefaultTaskDisplayArea().addChild(stack, POSITION_TOP);
verify(stack).onDisplayChanged(newDc);
diff --git a/services/tests/wmtests/src/com/android/server/wm/WindowOrganizerTests.java b/services/tests/wmtests/src/com/android/server/wm/WindowOrganizerTests.java
index 8fe65eb..dba157e 100644
--- a/services/tests/wmtests/src/com/android/server/wm/WindowOrganizerTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/WindowOrganizerTests.java
@@ -387,7 +387,7 @@
public void testSetIgnoreOrientationRequest_taskDisplayArea() {
removeGlobalMinSizeRestriction();
final TaskDisplayArea taskDisplayArea = mDisplayContent.getDefaultTaskDisplayArea();
- final Task stack = taskDisplayArea.createStack(
+ final Task stack = taskDisplayArea.createRootTask(
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, false /* onTop */);
final ActivityRecord activity = new ActivityBuilder(mAtm).setTask(stack).build();
taskDisplayArea.setIgnoreOrientationRequest(true /* ignoreOrientationRequest */);
@@ -425,7 +425,7 @@
public void testSetIgnoreOrientationRequest_displayContent() {
removeGlobalMinSizeRestriction();
final TaskDisplayArea taskDisplayArea = mDisplayContent.getDefaultTaskDisplayArea();
- final Task stack = taskDisplayArea.createStack(
+ final Task stack = taskDisplayArea.createRootTask(
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, false /* onTop */);
final ActivityRecord activity = new ActivityBuilder(mAtm).setTask(stack).build();
mDisplayContent.setFocusedApp(activity);
@@ -743,8 +743,8 @@
private List<Task> getTasksCreatedByOrganizer(DisplayContent dc) {
ArrayList<Task> out = new ArrayList<>();
dc.forAllTaskDisplayAreas(taskDisplayArea -> {
- for (int sNdx = taskDisplayArea.getStackCount() - 1; sNdx >= 0; --sNdx) {
- final Task t = taskDisplayArea.getStackAt(sNdx);
+ for (int sNdx = taskDisplayArea.getRootTaskCount() - 1; sNdx >= 0; --sNdx) {
+ final Task t = taskDisplayArea.getRootTaskAt(sNdx);
if (t.mCreatedByOrganizer) out.add(t);
}
});
diff --git a/services/tests/wmtests/src/com/android/server/wm/WindowTestsBase.java b/services/tests/wmtests/src/com/android/server/wm/WindowTestsBase.java
index 6c046bd..4c49c6e 100644
--- a/services/tests/wmtests/src/com/android/server/wm/WindowTestsBase.java
+++ b/services/tests/wmtests/src/com/android/server/wm/WindowTestsBase.java
@@ -797,7 +797,7 @@
mTask = new TaskBuilder(mService.mTaskSupervisor)
.setComponent(mComponent)
.setParentTask(mParentTask).build();
- } else if (mTask == null && mParentTask != null && DisplayContent.alwaysCreateStack(
+ } else if (mTask == null && mParentTask != null && DisplayContent.alwaysCreateRootTask(
mParentTask.getWindowingMode(), mParentTask.getActivityType())) {
// The stack can be the task root.
mTask = mParentTask;
@@ -871,7 +871,7 @@
activity.processName, activity.info.applicationInfo.uid);
// Resume top activities to make sure all other signals in the system are connected.
- mService.mRootWindowContainer.resumeFocusedStacksTopActivities();
+ mService.mRootWindowContainer.resumeFocusedTasksTopActivities();
return activity;
}
}
@@ -995,7 +995,7 @@
// Create parent task.
if (mParentTask == null && mCreateParentTask) {
- mParentTask = mTaskDisplayArea.createStack(
+ mParentTask = mTaskDisplayArea.createRootTask(
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */);
}
if (mParentTask != null && !Mockito.mockingDetails(mParentTask).isSpy()) {
@@ -1020,9 +1020,9 @@
}
Task task;
- final int taskId = mTaskId >= 0 ? mTaskId : mTaskDisplayArea.getNextStackId();
+ final int taskId = mTaskId >= 0 ? mTaskId : mTaskDisplayArea.getNextRootTaskId();
if (mParentTask == null) {
- task = mTaskDisplayArea.createStackUnchecked(
+ task = mTaskDisplayArea.createRootTaskUnchecked(
mWindowingMode, mActivityType, taskId, mOnTop, mActivityInfo, mIntent,
false /* createdByOrganizer */, false /* deferTaskAppear */,
null /* launchCookie */);
@@ -1114,8 +1114,8 @@
mSecondary.mRemoteToken.toWindowContainerToken());
DisplayContent dc = mService.mRootWindowContainer.getDisplayContent(mDisplayId);
dc.forAllTaskDisplayAreas(taskDisplayArea -> {
- for (int sNdx = taskDisplayArea.getStackCount() - 1; sNdx >= 0; --sNdx) {
- final Task stack = taskDisplayArea.getStackAt(sNdx);
+ for (int sNdx = taskDisplayArea.getRootTaskCount() - 1; sNdx >= 0; --sNdx) {
+ final Task stack = taskDisplayArea.getRootTaskAt(sNdx);
if (!WindowConfiguration.isSplitScreenWindowingMode(stack.getWindowingMode())) {
stack.reparent(mSecondary, POSITION_BOTTOM);
}
