diff options
| author | 2020-12-02 05:37:48 +0000 | |
|---|---|---|
| committer | 2020-12-02 05:37:48 +0000 | |
| commit | a9c6b43a7ecec30004cc8eb7a70b653511417272 (patch) | |
| tree | 162b556d4ec892bd8241757fec6dba1a6b0ef341 | |
| parent | 197e131bfc8d65b1834b49daed806621beb0b21e (diff) | |
| parent | 3319acf8ec028c9009915b9f3e0ceedc39431824 (diff) | |
Merge "Rename Stack to Task related terms (3/n)"
46 files changed, 861 insertions, 850 deletions
diff --git a/services/core/java/com/android/server/wm/ActivityMetricsLogger.java b/services/core/java/com/android/server/wm/ActivityMetricsLogger.java index b4ca7c5f6ff1..6a50b793de0f 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 @@ class ActivityMetricsLogger { 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 @@ class ActivityMetricsLogger { 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 75273ecb7534..02643ef04c94 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 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 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 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A // 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 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A false /* markFrozenIfConfigChanged */, true /* deferResume */); } if (activityRemoved) { - mRootWindowContainer.resumeFocusedStacksTopActivities(); + mRootWindowContainer.resumeFocusedTasksTopActivities(); } ProtoLog.d(WM_DEBUG_CONTAINERS, "destroyIfPossible: r=%s destroy returned " @@ -2849,7 +2849,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A mTaskSupervisor.mFinishingActivities.add(this); } resumeKeyDispatchingLocked(); - return mRootWindowContainer.resumeFocusedStacksTopActivities(); + return mRootWindowContainer.resumeFocusedTasksTopActivities(); } /** @@ -3014,7 +3014,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A removeFromHistory(reason); } - mRootWindowContainer.resumeFocusedStacksTopActivities(); + mRootWindowContainer.resumeFocusedTasksTopActivities(); } /** @@ -5206,7 +5206,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A } else { if (deferRelaunchUntilPaused) { destroyImmediately("stop-config"); - mRootWindowContainer.resumeFocusedStacksTopActivities(); + mRootWindowContainer.resumeFocusedTasksTopActivities(); } else { mRootWindowContainer.updatePreviousProcess(this); } @@ -5703,7 +5703,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A // 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 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A @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 b88b54ef08f5..0bea25174f06 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 @@ class ActivityStarter { 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 @@ class ActivityStarter { 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 @@ class ActivityStarter { 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 @@ class ActivityStarter { 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 @@ class ActivityStarter { // 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 @@ class ActivityStarter { // 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 @@ class ActivityStarter { 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 @@ class ActivityStarter { // 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 @@ class ActivityStarter { 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 @@ class ActivityStarter { // 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 @@ class ActivityStarter { 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 @@ class ActivityStarter { 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 8ba76be65cb6..3710120a7934 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 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { 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 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { 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 class ActivityTaskManagerService extends IActivityTaskManager.Stub { 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 class ActivityTaskManagerService extends IActivityTaskManager.Stub { 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 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { "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 class ActivityTaskManagerService extends IActivityTaskManager.Stub { 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 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { 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 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { 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 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { } final ActivityRecord r = task.topRunningActivityLocked(); if (r != null && r.moveFocusableActivityToTop("setFocusedTask")) { - mRootWindowContainer.resumeFocusedStacksTopActivities(); + mRootWindowContainer.resumeFocusedTasksTopActivities(); } } } finally { @@ -2508,7 +2508,7 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { 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 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { 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 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { 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 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { } 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 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { 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 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { "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 class ActivityTaskManagerService extends IActivityTaskManager.Stub { 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 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { 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 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { final long ident = Binder.clearCallingIdentity(); try { - return mRootWindowContainer.moveTopStackActivityToPinnedRootTask(rootTaskId); + return mRootWindowContainer.moveTopRootTaskActivityToPinnedRootTask(rootTaskId); } finally { Binder.restoreCallingIdentity(ident); } @@ -4113,7 +4113,7 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { 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 class ActivityTaskManagerService extends IActivityTaskManager.Stub { 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 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { 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 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { } } - Task getTopDisplayFocusedStack() { - return mRootWindowContainer.getTopDisplayFocusedStack(); + Task getTopDisplayFocusedRootTask() { + return mRootWindowContainer.getTopDisplayFocusedRootTask(); } /** Pokes the task persister. */ @@ -5827,7 +5827,7 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { /** 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 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { 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 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { "setFocusedActivity: No activity record matching token=" + token); } if (r.moveFocusableActivityToTop("setFocusedActivity")) { - mRootWindowContainer.resumeFocusedStacksTopActivities(); + mRootWindowContainer.resumeFocusedTasksTopActivities(); } } } @@ -6796,7 +6796,7 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { 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 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { if (mRootWindowContainer.finishDisabledPackageActivities( packageName, disabledClasses, true /* doit */, false /* evenPersistent */, userId, false /* onlyRemoveNoProcess */) && booted) { - mRootWindowContainer.resumeFocusedStacksTopActivities(); + mRootWindowContainer.resumeFocusedTasksTopActivities(); mTaskSupervisor.scheduleIdle(); } @@ -6879,7 +6879,7 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { @Override public void resumeTopActivities(boolean scheduleIdle) { synchronized (mGlobalLock) { - mRootWindowContainer.resumeFocusedStacksTopActivities(); + mRootWindowContainer.resumeFocusedTasksTopActivities(); if (scheduleIdle) { mTaskSupervisor.scheduleIdle(); } @@ -7056,7 +7056,7 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { 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 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { 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 d0c26af82d99..d94c7af0f190 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.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.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 @@ public class ActivityTaskSupervisor implements RecentTasks.Callbacks { /** 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 @@ public class ActivityTaskSupervisor implements RecentTasks.Callbacks { // 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 @@ public class ActivityTaskSupervisor implements RecentTasks.Callbacks { /** 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 @@ public class ActivityTaskSupervisor implements RecentTasks.Callbacks { 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 @@ public class ActivityTaskSupervisor implements RecentTasks.Callbacks { 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 @@ public class ActivityTaskSupervisor implements RecentTasks.Callbacks { // 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 @@ public class ActivityTaskSupervisor implements RecentTasks.Callbacks { 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 @@ public class ActivityTaskSupervisor implements RecentTasks.Callbacks { } if (!reparented) { - moveHomeStackToFrontIfNeeded(flags, currentStack.getDisplayArea(), reason); + moveHomeRootTaskToFrontIfNeeded(flags, currentStack.getDisplayArea(), reason); } final ActivityRecord r = task.getTopNonFinishingActivity(); @@ -1412,16 +1412,16 @@ public class ActivityTaskSupervisor implements RecentTasks.Callbacks { 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 @@ public class ActivityTaskSupervisor implements RecentTasks.Callbacks { } 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 @@ public class ActivityTaskSupervisor implements RecentTasks.Callbacks { * 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 @@ public class ActivityTaskSupervisor implements RecentTasks.Callbacks { 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 @@ public class ActivityTaskSupervisor implements RecentTasks.Callbacks { 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 @@ public class ActivityTaskSupervisor implements RecentTasks.Callbacks { */ 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 @@ public class ActivityTaskSupervisor implements RecentTasks.Callbacks { * 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 @@ public class ActivityTaskSupervisor implements RecentTasks.Callbacks { 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 @@ public class ActivityTaskSupervisor implements RecentTasks.Callbacks { 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 @@ public class ActivityTaskSupervisor implements RecentTasks.Callbacks { return; } - if (!mRootWindowContainer.putStacksToSleep( + if (!mRootWindowContainer.putTasksToSleep( allowDelay, false /* shuttingDown */)) { return; } @@ -1931,7 +1931,7 @@ public class ActivityTaskSupervisor implements RecentTasks.Callbacks { 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 @@ public class ActivityTaskSupervisor implements RecentTasks.Callbacks { */ 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 @@ public class ActivityTaskSupervisor implements RecentTasks.Callbacks { } } - void logStackState() { + void logRootTaskState() { mActivityMetricsLogger.logWindowState(); } @@ -2281,7 +2281,7 @@ public class ActivityTaskSupervisor implements RecentTasks.Callbacks { 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 @@ public class ActivityTaskSupervisor implements RecentTasks.Callbacks { 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 @@ public class ActivityTaskSupervisor implements RecentTasks.Callbacks { 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 @@ public class ActivityTaskSupervisor implements RecentTasks.Callbacks { // 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 4b349542e347..c22bd20da042 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 @@ public final class CompatModePackages { 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 5df50500f3e2..1d2cd0a0a350 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 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp 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. @@ -2243,26 +2243,26 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp * 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); } /** @@ -2926,7 +2926,7 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp 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() @@ -2970,7 +2970,7 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp 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); @@ -3068,13 +3068,13 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp 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()); } @@ -4516,9 +4516,9 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp } } - void assignStackOrdering() { + void assignRootTaskOrdering() { forAllTaskDisplayAreas(taskDisplayArea -> { - taskDisplayArea.assignStackOrdering(getPendingTransaction()); + taskDisplayArea.assignRootTaskOrdering(getPendingTransaction()); }); } @@ -5083,7 +5083,7 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp 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 @@ -5097,13 +5097,13 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp 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); } /** @@ -5340,19 +5340,19 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp // 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); @@ -5379,7 +5379,7 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp } 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 826b7259a9ff..2ddd00101769 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 @@ public class DisplayPolicy { // 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 @@ public class DisplayPolicy { 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 d308766b9fe5..ee150c31184c 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 @@ class InsetsPolicy { 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 ebd91a093326..e45310a99fbd 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 @@ class KeyguardController { 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 @@ class KeyguardController { @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 b6b172eeae5b..8745e95dba4d 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 @@ class LaunchParamsController { 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 ee3978746488..4b3a43432fc5 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 @@ public class LockTaskController { return; } task.performClearTaskLocked(); - mSupervisor.mRootWindowContainer.resumeFocusedStacksTopActivities(); + mSupervisor.mRootWindowContainer.resumeFocusedTasksTopActivities(); } /** @@ -640,7 +640,7 @@ public class LockTaskController { 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 @@ public class LockTaskController { } 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 ba6b27ac3252..5598937da63d 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.content.Intent.FLAG_ACTIVITY_NEW_TASK; 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 @@ class RecentTasks { 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 @@ class RecentTasks { @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 823dc51e939f..067c772dad93 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.ActivityTaskSupervisor.PRESERVE_WINDOWS; 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.PooledLambda; 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 @@ class RecentsAnimation implements RecentsAnimationCallbacks, 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 @@ class RecentsAnimation implements RecentsAnimationCallbacks, // 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 @@ class RecentsAnimation implements RecentsAnimationCallbacks, 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 @@ class RecentsAnimation implements RecentsAnimationCallbacks, 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 @@ class RecentsAnimation implements RecentsAnimationCallbacks, 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 @@ class RecentsAnimation implements RecentsAnimationCallbacks, 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 @@ class RecentsAnimation implements RecentsAnimationCallbacks, mWindowManager.getRecentsAnimationController(), reorderMode); // Unregister for stack order changes - mDefaultTaskDisplayArea.unregisterStackOrderChangedListener(this); + mDefaultTaskDisplayArea.unregisterRootTaskOrderChangedListener(this); final RecentsAnimationController controller = mWindowManager.getRecentsAnimationController(); @@ -303,7 +303,7 @@ class RecentsAnimation implements RecentsAnimationCallbacks, 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 @@ class RecentsAnimation implements RecentsAnimationCallbacks, } 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 @@ class RecentsAnimation implements RecentsAnimationCallbacks, 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 @@ class RecentsAnimation implements RecentsAnimationCallbacks, } @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 @@ class RecentsAnimation implements RecentsAnimationCallbacks, // 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 @@ class RecentsAnimation implements RecentsAnimationCallbacks, * @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 abee032d042a..5da668c8c361 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 @@ public class RecentsAnimationController implements DeathRecipient { 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 7bd5d03f1bc1..17cb8905f260 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 @@ class ResetTargetTaskHelper { 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 @@ class ResetTargetTaskHelper { } 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 cbeaecf7f58c..497087a967f3 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> /** 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> c.recycle(); } finally { mTaskSupervisor.endDeferResume(); - resumeFocusedStacksTopActivities(); + resumeFocusedTasksTopActivities(); } } } @@ -1484,7 +1484,7 @@ class RootWindowContainer extends WindowContainer<DisplayContent> 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> // 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> */ 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> } @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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> @Nullable ActivityRecord getTopResumedActivity() { - final Task focusedStack = getTopDisplayFocusedStack(); + final Task focusedStack = getTopDisplayFocusedRootTask(); if (focusedStack == null) { return null; } @@ -1879,8 +1879,8 @@ class RootWindowContainer extends WindowContainer<DisplayContent> 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> // 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> } 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> // 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> } 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> * @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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> /** * 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> // 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> } ensureActivitiesVisible(null, 0, false /* preserveWindows */); - resumeFocusedStacksTopActivities(); + resumeFocusedTasksTopActivities(); notifyActivityPipModeChanged(r); } @@ -2288,13 +2291,13 @@ class RootWindowContainer extends WindowContainer<DisplayContent> * @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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> // 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> // 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> } } - 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> } RootTaskInfo getRootTaskInfo(int taskId) { - Task task = getStack(taskId); + Task task = getRootTask(taskId); if (task != null) { return getRootTaskInfo(task); } @@ -2496,12 +2499,12 @@ class RootWindowContainer extends WindowContainer<DisplayContent> } 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> * @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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> } // 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> } } - 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> * @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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> * 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> continue; } final Task nextFocusableStack = display.getDefaultTaskDisplayArea() - .getNextFocusableStack(currentFocus, ignoreCurrent); + .getNextFocusableRootTask(currentFocus, ignoreCurrent); if (nextFocusableStack != null) { return nextFocusableStack; } @@ -3257,9 +3259,9 @@ class RootWindowContainer extends WindowContainer<DisplayContent> 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> // 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> // 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> } 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> 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 7b5b0ad870dd..6ef5d4da63cb 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 @@ class RunningTasks { 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 fb441fa94893..4b65ce0f7088 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_USER_ 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 @@ class Task extends WindowContainer<WindowContainer> { 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 @@ class Task extends WindowContainer<WindowContainer> { 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 @@ class Task extends WindowContainer<WindowContainer> { } mResizeMode = resizeMode; mRootWindowContainer.ensureActivitiesVisible(null, 0, !PRESERVE_WINDOWS); - mRootWindowContainer.resumeFocusedStacksTopActivities(); + mRootWindowContainer.resumeFocusedTasksTopActivities(); updateTaskDescription(); } @@ -1030,7 +1030,7 @@ class Task extends WindowContainer<WindowContainer> { // activities stay the same. mRootWindowContainer.ensureActivitiesVisible(r, 0, preserveWindow); if (!kept) { - mRootWindowContainer.resumeFocusedStacksTopActivities(); + mRootWindowContainer.resumeFocusedTasksTopActivities(); } } } @@ -1098,7 +1098,7 @@ class Task extends WindowContainer<WindowContainer> { 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 @@ class Task extends WindowContainer<WindowContainer> { 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 @@ class Task extends WindowContainer<WindowContainer> { && 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 @@ class Task extends WindowContainer<WindowContainer> { // 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 @@ class Task extends WindowContainer<WindowContainer> { // 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 @@ class Task extends WindowContainer<WindowContainer> { // 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 @@ class Task extends WindowContainer<WindowContainer> { } if (prevWindowingMode != getWindowingMode()) { - taskDisplayArea.onStackWindowingModeChanged(this); + taskDisplayArea.onRootTaskWindowingModeChanged(this); } if (mDisplayContent == null) { @@ -2330,7 +2330,7 @@ class Task extends WindowContainer<WindowContainer> { } if (windowingModeChanged) { - taskDisplayArea.onStackWindowingModeChanged(this); + taskDisplayArea.onRootTaskWindowingModeChanged(this); } if (hasNewOverrideBounds) { if (inSplitScreenWindowingMode()) { @@ -3097,7 +3097,7 @@ class Task extends WindowContainer<WindowContainer> { 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 @@ class Task extends WindowContainer<WindowContainer> { // 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 @@ class Task extends WindowContainer<WindowContainer> { } 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 @@ class Task extends WindowContainer<WindowContainer> { // 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 @@ class Task extends WindowContainer<WindowContainer> { 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 @@ class Task extends WindowContainer<WindowContainer> { 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 @@ class Task extends WindowContainer<WindowContainer> { 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 @@ class Task extends WindowContainer<WindowContainer> { // 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 @@ class Task extends WindowContainer<WindowContainer> { } 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 @@ class Task extends WindowContainer<WindowContainer> { // 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 @@ class Task extends WindowContainer<WindowContainer> { boolean isTopStackInDisplayArea() { final TaskDisplayArea taskDisplayArea = getDisplayArea(); - return taskDisplayArea != null && taskDisplayArea.isTopStack(this); + return taskDisplayArea != null && taskDisplayArea.isTopRootTask(this); } /** @@ -5717,7 +5717,7 @@ class Task extends WindowContainer<WindowContainer> { * otherwise. */ boolean isFocusedStackOnDisplay() { - return mDisplayContent != null && this == mDisplayContent.getFocusedStack(); + return mDisplayContent != null && this == mDisplayContent.getFocusedRootTask(); } /** @@ -5795,7 +5795,7 @@ class Task extends WindowContainer<WindowContainer> { */ boolean isTopSplitScreenStack() { return inSplitScreenWindowingMode() - && this == getDisplayArea().getTopStackInWindowingMode(getWindowingMode()); + && this == getDisplayArea().getTopRootTaskInWindowingMode(getWindowingMode()); } void checkTranslucentActivityWaiting(ActivityRecord top) { @@ -5879,7 +5879,7 @@ class Task extends WindowContainer<WindowContainer> { * * 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 @@ class Task extends WindowContainer<WindowContainer> { 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 @@ class Task extends WindowContainer<WindowContainer> { } } - 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 @@ class Task extends WindowContainer<WindowContainer> { // 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 @@ class Task extends WindowContainer<WindowContainer> { // 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 @@ class Task extends WindowContainer<WindowContainer> { 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 @@ class Task extends WindowContainer<WindowContainer> { } if (!deferResume) { - mRootWindowContainer.resumeFocusedStacksTopActivities(); + mRootWindowContainer.resumeFocusedTasksTopActivities(); } } finally { mDisplayContent.continueUpdateImeTarget(); @@ -6975,7 +6975,7 @@ class Task extends WindowContainer<WindowContainer> { // resumed in this case, so we need to execute it explicitly. mDisplayContent.executeAppTransition(); } else { - mRootWindowContainer.resumeFocusedStacksTopActivities(); + mRootWindowContainer.resumeFocusedTasksTopActivities(); } return true; } @@ -7280,7 +7280,7 @@ class Task extends WindowContainer<WindowContainer> { 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 @@ class Task extends WindowContainer<WindowContainer> { // 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 @@ class Task extends WindowContainer<WindowContainer> { // 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 4682ba836426..b4d069c0edc1 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 @@ class TaskChangeNotificationController { 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 81b8200aa2b4..4498a8c82583 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_ORIENTATION; 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { // 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { * 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { * 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { } @VisibleForTesting - Task getTopStack() { + Task getTopRootTask() { final int count = getChildCount(); return count > 0 ? getChildAt(count - 1) : null; } @@ -255,68 +257,68 @@ final class TaskDisplayArea extends DisplayArea<Task> { 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { // 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { * (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 @@ final class TaskDisplayArea extends DisplayArea<Task> { 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { } 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { @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 @@ final class TaskDisplayArea extends DisplayArea<Task> { } } - 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { 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 class TaskDisplayArea extends DisplayArea<Task> { 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { } } - 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { } } - 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { * 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { * 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { } return stack; } - return createStack(windowingMode, activityType, onTop, null /*info*/, intent, + return createRootTask(windowingMode, activityType, onTop, null /*info*/, intent, false /* createdByOrganizer */); } @@ -967,9 +969,9 @@ final class TaskDisplayArea extends DisplayArea<Task> { * 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { // 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { * 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { // 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { } @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 @@ final class TaskDisplayArea extends DisplayArea<Task> { * 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { // 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { return resumedActivity; } - Task getLastFocusedStack() { - return mLastFocusedStack; + Task getLastFocusedRootTask() { + return mLastFocusedRootTask; } void updateLastFocusedRootTask(Task prevFocusedTask, String updateLastFocusedTaskReason) { @@ -1203,7 +1205,7 @@ final class TaskDisplayArea extends DisplayArea<Task> { return; } - final Task currentFocusedTask = getFocusedStack(); + final Task currentFocusedTask = getFocusedRootTask(); if (currentFocusedTask == prevFocusedTask) { return; } @@ -1214,27 +1216,27 @@ final class TaskDisplayArea extends DisplayArea<Task> { 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { * @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 @@ final class TaskDisplayArea extends DisplayArea<Task> { 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { // 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { return windowingMode; } - boolean isTopStack(Task stack) { - return stack == getTopStack(); + boolean isTopRootTask(Task stack) { + return stack == getTopRootTask(); } ActivityRecord topRunningActivity() { @@ -1575,15 +1577,15 @@ final class TaskDisplayArea extends DisplayArea<Task> { */ 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { * 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { void moveHomeActivityToTop(String reason) { final ActivityRecord top = getHomeActivity(); if (top == null) { - moveHomeStackToFront(reason); + moveHomeRootTaskToFront(reason); return; } top.moveFocusableActivityToTop(reason); @@ -1697,25 +1697,27 @@ final class TaskDisplayArea extends DisplayArea<Task> { /** * 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { || 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { /** * 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { // 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { * @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 @@ final class TaskDisplayArea extends DisplayArea<Task> { * 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { /** * 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { * @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 @@ final class TaskDisplayArea extends DisplayArea<Task> { // 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { } // 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 @@ final class TaskDisplayArea extends DisplayArea<Task> { 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 8b2fa52afd22..9d36b84431f3 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 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier { @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 009a7ef9e4f2..e635219bc6e5 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 @@ class TaskOrganizerController extends ITaskOrganizerController.Stub { // 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 @@ class TaskOrganizerController extends ITaskOrganizerController.Stub { } 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 7d61c1973a2a..7809cbc2a167 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 @@ class WallpaperController { 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 25049ae6d8b5..f8b5914d3e53 100644 --- a/services/core/java/com/android/server/wm/WindowManagerService.java +++ b/services/core/java/com/android/server/wm/WindowManagerService.java @@ -2922,7 +2922,7 @@ public class WindowManagerService extends IWindowManager.Stub } 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 9a6eb1cf2623..99bd0d7198c0 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 @@ public class ActivityDisplayTests extends WindowTestsBase { 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 class ActivityDisplayTests extends WindowTestsBase { 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 @@ public class ActivityDisplayTests extends WindowTestsBase { } /** - * 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 @@ public class ActivityDisplayTests extends WindowTestsBase { 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 @@ public class ActivityDisplayTests extends WindowTestsBase { 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 @@ public class ActivityDisplayTests extends WindowTestsBase { // 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 @@ public class ActivityDisplayTests extends WindowTestsBase { // 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 @@ public class ActivityDisplayTests extends WindowTestsBase { @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 @@ public class ActivityDisplayTests extends WindowTestsBase { 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 @@ public class ActivityDisplayTests extends WindowTestsBase { 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 @@ public class ActivityDisplayTests extends WindowTestsBase { 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 @@ public class ActivityDisplayTests extends WindowTestsBase { // 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 2304efcaef65..28c31843de57 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 @@ public class ActivityRecordTests extends WindowTestsBase { 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 @@ public class ActivityRecordTests extends WindowTestsBase { topRootableTask.moveToFront("test"); assertTrue(topRootableTask.isTopStackInDisplayArea()); assertEquals(topRootableTask, topActivityOnNonTopDisplay.getDisplayArea() - .mPreferredTopFocusableStack); + .mPreferredTopFocusableRootTask); final ActivityRecord secondaryDisplayActivity = createActivityOnDisplay(false /* defaultDisplay */, null /* process */); @@ -883,7 +883,7 @@ public class ActivityRecordTests extends WindowTestsBase { 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 @@ public class ActivityRecordTests extends WindowTestsBase { 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 @@ public class ActivityRecordTests extends WindowTestsBase { @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 @@ public class ActivityRecordTests extends WindowTestsBase { 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 8ccbb8fe62ad..8e3e668804ff 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.REPARENT_MOVE_ROOT_TASK_TO_FRONT; 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 android.platform.test.annotations.Presubmit; 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 @@ public class ActivityStackTests extends WindowTestsBase { 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 class ActivityStackTests extends WindowTestsBase { 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 @@ public class ActivityStackTests extends WindowTestsBase { 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 @@ public class ActivityStackTests extends WindowTestsBase { @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 @@ public class ActivityStackTests extends WindowTestsBase { @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 @@ public class ActivityStackTests extends WindowTestsBase { 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 @@ public class ActivityStackTests extends WindowTestsBase { // 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 @@ public class ActivityStackTests extends WindowTestsBase { // 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 @@ public class ActivityStackTests extends WindowTestsBase { // 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 @@ public class ActivityStackTests extends WindowTestsBase { // 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 @@ public class ActivityStackTests extends WindowTestsBase { // 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 @@ public class ActivityStackTests extends WindowTestsBase { // 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 @@ public class ActivityStackTests extends WindowTestsBase { 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 @@ public class ActivityStackTests extends WindowTestsBase { 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 @@ public class ActivityStackTests extends WindowTestsBase { 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 @@ public class ActivityStackTests extends WindowTestsBase { 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 @@ public class ActivityStackTests extends WindowTestsBase { 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 @@ public class ActivityStackTests extends WindowTestsBase { @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 @@ public class ActivityStackTests extends WindowTestsBase { @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 @@ public class ActivityStackTests extends WindowTestsBase { 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 c799f2902547..ce96771c8c27 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 android.platform.test.annotations.Presubmit; 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 @@ public class ActivityStartControllerTests extends WindowTestsBase { .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 @@ public class ActivityStartControllerTests extends WindowTestsBase { 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 565bf8b615c7..ef2e88913914 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 @@ public class ActivityStarterTests extends WindowTestsBase { * 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 @@ public class ActivityStarterTests extends WindowTestsBase { 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 @@ public class ActivityStarterTests extends WindowTestsBase { 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 @@ public class ActivityStarterTests extends WindowTestsBase { 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 @@ public class ActivityStarterTests extends WindowTestsBase { 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 @@ public class ActivityStarterTests extends WindowTestsBase { 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 @@ public class ActivityStarterTests extends WindowTestsBase { 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 @@ public class ActivityStarterTests extends WindowTestsBase { // 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 @@ public class ActivityStarterTests extends WindowTestsBase { 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 @@ public class ActivityStarterTests extends WindowTestsBase { 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 39bf8eb857b0..5a47493c12cd 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 @@ public class DisplayAreaPolicyTests { @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 @@ public class DisplayAreaPolicyTests { .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 64065e96b0f2..2053bfb45884 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 @@ public class DisplayContentTests extends WindowTestsBase { 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 @@ public class DisplayContentTests extends WindowTestsBase { 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 cd428e10a437..a99e40cc19ec 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 @@ public class LaunchParamsControllerTests extends WindowTestsBase { 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 d701a9df7cb8..b7d8638f06a8 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 @@ public class LaunchParamsPersisterTests extends WindowTestsBase { .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 class LaunchParamsPersisterTests extends WindowTestsBase { 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 @@ public class LaunchParamsPersisterTests extends WindowTestsBase { 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 7812934bb52f..4892ef3b6322 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 @@ public class RecentTasksTest extends WindowTestsBase { 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 @@ public class RecentTasksTest extends WindowTestsBase { 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 @@ public class RecentTasksTest extends WindowTestsBase { 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 class RecentTasksTest extends WindowTestsBase { 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 class RecentTasksTest extends WindowTestsBase { 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 @@ public class RecentTasksTest extends WindowTestsBase { 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 5ff3ff5a6e0c..63ee5d05fada 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 @@ public class RecentsAnimationTest extends WindowTestsBase { @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 class RecentsAnimationTest extends WindowTestsBase { 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 @@ public class RecentsAnimationTest extends WindowTestsBase { 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 class RecentsAnimationTest extends WindowTestsBase { 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 @@ public class RecentsAnimationTest extends WindowTestsBase { @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 @@ public class RecentsAnimationTest extends WindowTestsBase { @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 class RecentsAnimationTest extends WindowTestsBase { 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 @@ public class RecentsAnimationTest extends WindowTestsBase { .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 7ca364cf096f..f79e4cc9fa10 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 @@ public class RootActivityContainerTests extends WindowTestsBase { @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 @@ public class RootActivityContainerTests extends WindowTestsBase { 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 @@ public class RootActivityContainerTests extends WindowTestsBase { 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 @@ public class RootActivityContainerTests extends WindowTestsBase { // Move first activity to pinned stack. - mRootWindowContainer.moveActivityToPinnedStack(secondActivity, "initialMove"); + mRootWindowContainer.moveActivityToPinnedRootTask(secondActivity, "initialMove"); assertTrue(firstActivity.mRequestForceTransition); } @@ -237,9 +237,9 @@ public class RootActivityContainerTests extends WindowTestsBase { 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 class RootActivityContainerTests extends WindowTestsBase { 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 class RootActivityContainerTests extends WindowTestsBase { 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 @@ public class RootActivityContainerTests extends WindowTestsBase { 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 class RootActivityContainerTests extends WindowTestsBase { 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 @@ public class RootActivityContainerTests extends WindowTestsBase { 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 @@ public class RootActivityContainerTests extends WindowTestsBase { false); final TaskDisplayArea taskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea(); - verify(taskDisplayArea).moveHomeStackToFront(contains(reason)); + verify(taskDisplayArea).moveHomeRootTaskToFront(contains(reason)); } /** @@ -421,7 +421,7 @@ public class RootActivityContainerTests extends WindowTestsBase { 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 @@ public class RootActivityContainerTests extends WindowTestsBase { 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 @@ public class RootActivityContainerTests extends WindowTestsBase { 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 class RootActivityContainerTests extends WindowTestsBase { 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 @@ public class RootActivityContainerTests extends WindowTestsBase { // 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 @@ public class RootActivityContainerTests extends WindowTestsBase { 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 @@ public class RootActivityContainerTests extends WindowTestsBase { 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 @@ public class RootActivityContainerTests extends WindowTestsBase { 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 class RootActivityContainerTests extends WindowTestsBase { 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 @@ public class RootActivityContainerTests extends WindowTestsBase { 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 class RootActivityContainerTests extends WindowTestsBase { 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 @@ public class RootActivityContainerTests extends WindowTestsBase { // 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 @@ public class RootActivityContainerTests extends WindowTestsBase { 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 @@ public class RootActivityContainerTests extends WindowTestsBase { } /** - * 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 @@ public class RootActivityContainerTests extends WindowTestsBase { 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 @@ public class RootActivityContainerTests extends WindowTestsBase { 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 @@ public class RootActivityContainerTests extends WindowTestsBase { @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 @@ public class RootActivityContainerTests extends WindowTestsBase { 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 42193c8fce78..9af2b96f3f78 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 class RootWindowContainerTests extends WindowTestsBase { 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 95e344d5c184..6821d47d5b1a 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 @@ public class RunningTasksTest extends WindowTestsBase { 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 2db736e63391..536ef48065a5 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 @@ public class SystemServicesTestRule implements TestRule { // 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 28ba710797c9..d80f81642474 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 @@ public class TaskDisplayAreaTests extends WindowTestsBase { 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 @@ public class TaskDisplayAreaTests extends WindowTestsBase { 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 @@ public class TaskDisplayAreaTests extends WindowTestsBase { @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 @@ public class TaskDisplayAreaTests extends WindowTestsBase { 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 4f55322e2085..269ce5d833f2 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 @@ public class TaskLaunchParamsModifierTests extends WindowTestsBase { 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 61d4a473215b..4a5ff58fca3c 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 class TaskRecordTests extends WindowTestsBase { 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 @@ public class TaskRecordTests extends WindowTestsBase { @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 @@ public class TaskRecordTests extends WindowTestsBase { 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 @@ public class TaskRecordTests extends WindowTestsBase { 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 573da896eff3..c4bcfdbcf89d 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 @@ public class WindowContainerTests extends WindowTestsBase { 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 8fe65eb2747d..dba157e6ce06 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 class WindowOrganizerTests extends WindowTestsBase { 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 class WindowOrganizerTests extends WindowTestsBase { 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 @@ public class WindowOrganizerTests extends WindowTestsBase { 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 6c046bda1444..4c49c6e4f0b9 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 @@ class WindowTestsBase extends SystemServiceTestsBase { 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 @@ class WindowTestsBase extends SystemServiceTestsBase { 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 @@ class WindowTestsBase extends SystemServiceTestsBase { // 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 @@ class WindowTestsBase extends SystemServiceTestsBase { } 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 @@ class WindowTestsBase extends SystemServiceTestsBase { 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); } |