diff options
45 files changed, 463 insertions, 481 deletions
diff --git a/services/core/java/com/android/server/wm/ActivityStack.java b/services/core/java/com/android/server/wm/ActivityStack.java index 10b335e583b0..a446720c1c39 100644 --- a/services/core/java/com/android/server/wm/ActivityStack.java +++ b/services/core/java/com/android/server/wm/ActivityStack.java @@ -3553,9 +3553,8 @@ class ActivityStack extends Task { } } - void reparent(DisplayContent newParent, boolean onTop) { - // Real parent of stack is within display object, so we have to delegate re-parenting there. - newParent.moveStackToDisplay(this, onTop); + void reparent(TaskDisplayArea newParent, boolean onTop) { + reparent(newParent, onTop ? POSITION_TOP : POSITION_BOTTOM); } private void updateSurfaceBounds() { diff --git a/services/core/java/com/android/server/wm/ActivityStackSupervisor.java b/services/core/java/com/android/server/wm/ActivityStackSupervisor.java index 2c7ce9104c3c..8af862473386 100644 --- a/services/core/java/com/android/server/wm/ActivityStackSupervisor.java +++ b/services/core/java/com/android/server/wm/ActivityStackSupervisor.java @@ -412,7 +412,7 @@ public class ActivityStackSupervisor implements RecentTasks.Callbacks { final ActivityStack stack = (ActivityStack) task; stack.setWindowingMode(WINDOWING_MODE_FULLSCREEN); if (mToDisplay.getDisplayId() != stack.getDisplayId()) { - mToDisplay.moveStackToDisplay(stack, mOnTop); + stack.reparent(mToDisplay.getDefaultTaskDisplayArea(), mOnTop); } else if (mOnTop) { mToDisplay.mTaskContainers.positionStackAtTop(stack, false /* includingParents */); @@ -566,8 +566,8 @@ public class ActivityStackSupervisor implements RecentTasks.Callbacks { } void moveRecentsStackToFront(String reason) { - final ActivityStack recentsStack = mRootWindowContainer.getDefaultDisplay().getStack( - WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_RECENTS); + final ActivityStack recentsStack = mRootWindowContainer.getDefaultTaskDisplayArea() + .getStack(WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_RECENTS); if (recentsStack != null) { recentsStack.moveToFront(reason); } @@ -2613,7 +2613,7 @@ public class ActivityStackSupervisor 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.getDefaultDisplay().mTaskContainers.moveHomeStackToFront( + mRootWindowContainer.getDefaultTaskDisplayArea().moveHomeStackToFront( "startActivityFromRecents"); } diff --git a/services/core/java/com/android/server/wm/ActivityTaskManagerService.java b/services/core/java/com/android/server/wm/ActivityTaskManagerService.java index 7803c7370dac..0b1968765300 100644 --- a/services/core/java/com/android/server/wm/ActivityTaskManagerService.java +++ b/services/core/java/com/android/server/wm/ActivityTaskManagerService.java @@ -4283,9 +4283,9 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { long ident = Binder.clearCallingIdentity(); try { synchronized (mGlobalLock) { - final DisplayContent dc = mRootWindowContainer.getDefaultDisplay(); - final Task primary = dc.getRootSplitScreenPrimaryTask(); - final Task secondary = dc.getTask(t -> t.mCreatedByOrganizer && t.isRootTask() + final TaskDisplayArea tc = mRootWindowContainer.getDefaultTaskDisplayArea(); + final Task primary = tc.getRootSplitScreenPrimaryTask(); + final Task secondary = tc.getTask(t -> t.mCreatedByOrganizer && t.isRootTask() && t.inSplitScreenSecondaryWindowingMode()); if (primary == null || secondary == null) { return; @@ -4301,7 +4301,7 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { if (otherRect == null) { // Temporary estimation... again this is just for tests. otherRect = new Rect(secondary.getBounds()); - if (dc.getBounds().width() > dc.getBounds().height()) { + if (tc.getBounds().width() > tc.getBounds().height()) { otherRect.left = primaryRect.right + 6; } else { otherRect.top = primaryRect.bottom + 6; diff --git a/services/core/java/com/android/server/wm/DisplayAreaPolicyBuilder.java b/services/core/java/com/android/server/wm/DisplayAreaPolicyBuilder.java index 682a14220dff..e8becfa27fac 100644 --- a/services/core/java/com/android/server/wm/DisplayAreaPolicyBuilder.java +++ b/services/core/java/com/android/server/wm/DisplayAreaPolicyBuilder.java @@ -54,7 +54,7 @@ import java.util.Map; * - DisplayArea.Root * - Magnification * - DisplayArea.Tokens (Wallpapers are attached here) - * - TaskContainers + * - TaskDisplayArea * - DisplayArea.Tokens (windows above Tasks up to IME are attached here) * - ImeContainers * - DisplayArea.Tokens (windows above IME up to TYPE_ACCESSIBILITY_OVERLAY attached here) diff --git a/services/core/java/com/android/server/wm/DisplayContent.java b/services/core/java/com/android/server/wm/DisplayContent.java index 55b7be779690..85517a44d656 100644 --- a/services/core/java/com/android/server/wm/DisplayContent.java +++ b/services/core/java/com/android/server/wm/DisplayContent.java @@ -575,13 +575,6 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo private RootWindowContainer mRootWindowContainer; - /** - * 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()}. - */ - private ArrayList<OnStackOrderChangedListener> mStackOrderChangedCallbacks = new ArrayList<>(); - /** Array of all UIDs that are present on the display. */ private IntArray mDisplayAccessUIDs = new IntArray(); @@ -2062,23 +2055,6 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo return (mDisplay.getFlags() & FLAG_PRIVATE) != 0; } - ActivityStack getRootHomeTask() { - return mTaskContainers.getRootHomeTask(); - } - - /** @return The primary split-screen task, and {@code null} otherwise. */ - @Nullable ActivityStack getRootSplitScreenPrimaryTask() { - return mTaskContainers.getRootSplitScreenPrimaryTask(); - } - - ActivityStack getRootPinnedTask() { - return mTaskContainers.getRootPinnedTask(); - } - - boolean hasPinnedTask() { - return mTaskContainers.getRootPinnedTask() != null; - } - /** * 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. @@ -2095,32 +2071,11 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo return mTaskContainers.mChildren.get(index); } - int getIndexOf(ActivityStack stack) { - return mTaskContainers.getIndexOf(stack); - } - - void removeStack(ActivityStack stack) { - mTaskContainers.removeChild(stack); - } - - @VisibleForTesting - WindowList<ActivityStack> getStacks() { - return mTaskContainers.mChildren; - } - @VisibleForTesting ActivityStack getTopStack() { return mTaskContainers.getTopStack(); } - ArrayList<Task> getVisibleTasks() { - return mTaskContainers.getVisibleTasks(); - } - - SurfaceControl getSplitScreenDividerAnchor() { - return mTaskContainers.getSplitScreenDividerAnchor(); - } - /** * The value is only valid in the scope {@link #onRequestedOverrideConfigurationChanged} of the * changing hierarchy and the {@link #onConfigurationChanged} of its children. @@ -2409,8 +2364,13 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo out.set(mDisplayFrames.mStable); } - void moveStackToDisplay(ActivityStack stack, boolean onTop) { - stack.reparent(mTaskContainers, onTop ? POSITION_TOP: POSITION_BOTTOM); + /** + * Get the default display area on the display dedicated to app windows. This one should be used + * only as a fallback location for activity launches when no target display area is specified, + * or for cases when multi-instance is not supported yet (like Split-screen, PiP or Recents). + */ + TaskDisplayArea getDefaultTaskDisplayArea() { + return mTaskContainers; } @Override @@ -2473,7 +2433,7 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo */ Task findTaskForResizePoint(int x, int y) { final int delta = dipToPixel(RESIZE_HANDLE_WIDTH_IN_DP, mDisplayMetrics); - return mTmpTaskForResizePointSearchResult.process(mTaskContainers, x, y, delta); + return mTmpTaskForResizePointSearchResult.process(getDefaultTaskDisplayArea(), x, y, delta); } void updateTouchExcludeRegion() { @@ -2512,8 +2472,9 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo mTouchExcludeRegion.op(mTmpRegion, Region.Op.UNION); } amendWindowTapExcludeRegion(mTouchExcludeRegion); - // TODO(multi-display): Support docked stacks on secondary displays. - if (mDisplayId == DEFAULT_DISPLAY && mTaskContainers.isSplitScreenModeActivated()) { + // TODO(multi-display): Support docked stacks on secondary displays & task containers. + if (mDisplayId == DEFAULT_DISPLAY + && getDefaultTaskDisplayArea().isSplitScreenModeActivated()) { mDividerControllerLocked.getTouchRegion(mTmpRect); mTmpRegion.set(mTmpRect); mTouchExcludeRegion.op(mTmpRegion, Op.UNION); @@ -2908,20 +2869,22 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo pw.println(); // Dump stack references - final ActivityStack homeStack = getRootHomeTask(); + final ActivityStack homeStack = getDefaultTaskDisplayArea().getRootHomeTask(); if (homeStack != null) { pw.println(prefix + "homeStack=" + homeStack.getName()); } - final ActivityStack pinnedStack = getRootPinnedTask(); + final ActivityStack pinnedStack = getDefaultTaskDisplayArea().getRootPinnedTask(); if (pinnedStack != null) { pw.println(prefix + "pinnedStack=" + pinnedStack.getName()); } - final ActivityStack splitScreenPrimaryStack = getRootSplitScreenPrimaryTask(); + final ActivityStack splitScreenPrimaryStack = getDefaultTaskDisplayArea() + .getRootSplitScreenPrimaryTask(); if (splitScreenPrimaryStack != null) { pw.println(prefix + "splitScreenPrimaryStack=" + splitScreenPrimaryStack.getName()); } - final ActivityStack recentsStack = - getStack(WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_RECENTS); + // TODO: Support recents on non-default task containers + final ActivityStack recentsStack = getDefaultTaskDisplayArea().getStack( + WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_RECENTS); if (recentsStack != null) { pw.println(prefix + "recentsStack=" + recentsStack.getName()); } @@ -2955,12 +2918,6 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo return "Display " + mDisplayId + " name=\"" + mDisplayInfo.name + "\""; } - /** Returns true if the stack in the windowing mode is visible. */ - boolean isStackVisible(int windowingMode) { - final ActivityStack stack = mTaskContainers.getTopStackInWindowingMode(windowingMode); - return stack != null && stack.isVisible(); - } - /** Find the visible, touch-deliverable window under the given point */ WindowState getTouchableWinAtPointLocked(float xf, float yf) { final int x = (int) xf; @@ -4367,7 +4324,7 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo // We skip IME windows so they're processed just above their target, except // in split-screen mode where we process the IME containers above the docked divider. return dc.mInputMethodTarget != null - && !dc.mTaskContainers.isSplitScreenModeActivated(); + && !dc.getDefaultTaskDisplayArea().isSplitScreenModeActivated(); } /** Like {@link #forAllWindows}, but ignores {@link #skipImeWindowsDuringTraversal} */ @@ -5262,7 +5219,7 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo // released (no more ActivityStack). But, we cannot release it at that moment or the // related WindowContainer will also be removed. So, we set display as removed after // reparenting stack finished. - final DisplayContent toDisplay = mRootWindowContainer.getDefaultDisplay(); + final TaskDisplayArea toTaskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea(); mRootWindowContainer.mStackSupervisor.beginDeferResume(); try { int numStacks = getStackCount(); @@ -5276,10 +5233,10 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo // If default display is in split-window mode, set windowing mode of the stack // to split-screen secondary. Otherwise, set the windowing mode to undefined by // default to let stack inherited the windowing mode from the new display. - final int windowingMode = toDisplay.mTaskContainers.isSplitScreenModeActivated() + final int windowingMode = toTaskDisplayArea.isSplitScreenModeActivated() ? WINDOWING_MODE_SPLIT_SCREEN_SECONDARY : WINDOWING_MODE_UNDEFINED; - stack.reparent(toDisplay, true /* onTop */); + stack.reparent(toTaskDisplayArea, true /* onTop */); stack.setWindowingMode(windowingMode); lastReparentedStack = stack; } @@ -5392,34 +5349,6 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo mSleeping = asleep; } - /** - * Adds a listener to be notified whenever the stack order in the display changes. Currently - * 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); - } - } - - /** - * Removes a previously registered stack order change listener. - */ - void unregisterStackOrderChangedListener(OnStackOrderChangedListener listener) { - mStackOrderChangedCallbacks.remove(listener); - } - - /** - * Notifies of a stack order change - * @param stack The stack which triggered the order change - */ - void onStackOrderChanged(ActivityStack stack) { - for (int i = mStackOrderChangedCallbacks.size() - 1; i >= 0; i--) { - mStackOrderChangedCallbacks.get(i).onStackOrderChanged(stack); - } - } - void setDisplayToSingleTaskInstance() { final int childCount = getStackCount(); if (childCount > 1) { @@ -5448,22 +5377,6 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo } /** - * Callback for when the order of the stacks in the display changes. - */ - interface OnStackOrderChangedListener { - void onStackOrderChanged(ActivityStack stack); - } - - public void dumpStacks(PrintWriter pw) { - for (int i = getStackCount() - 1; i >= 0; --i) { - pw.print(getStackAt(i).getRootTaskId()); - if (i > 0) { - pw.print(","); - } - } - } - - /** * Similar to {@link RootWindowContainer#isAnyNonToastWindowVisibleForUid(int)}, but * used for pid. */ diff --git a/services/core/java/com/android/server/wm/DisplayPolicy.java b/services/core/java/com/android/server/wm/DisplayPolicy.java index 221258e94cb2..264da9fc681b 100644 --- a/services/core/java/com/android/server/wm/DisplayPolicy.java +++ b/services/core/java/com/android/server/wm/DisplayPolicy.java @@ -2653,8 +2653,8 @@ public class DisplayPolicy { if (mStatusBarController.setBarShowingLw(true)) { changes |= FINISH_LAYOUT_REDO_LAYOUT; } - } else if (topIsFullscreen - && !mDisplayContent.isStackVisible(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY)) { + } else if (topIsFullscreen && !mDisplayContent.getDefaultTaskDisplayArea() + .isStackVisible(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY)) { if (DEBUG_LAYOUT) Slog.v(TAG, "** HIDING status bar"); if (mStatusBarController.setBarShowingLw(false)) { changes |= FINISH_LAYOUT_REDO_LAYOUT; @@ -3462,10 +3462,10 @@ public class DisplayPolicy { } private Pair<Integer, WindowState> updateSystemBarsLw(WindowState win, int oldVis, int vis) { - final boolean dockedStackVisible = - mDisplayContent.isStackVisible(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY); - final boolean freeformStackVisible = - mDisplayContent.isStackVisible(WINDOWING_MODE_FREEFORM); + final boolean dockedStackVisible = mDisplayContent.getDefaultTaskDisplayArea() + .isStackVisible(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY); + final boolean freeformStackVisible = mDisplayContent.getDefaultTaskDisplayArea() + .isStackVisible(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/DisplayRotation.java b/services/core/java/com/android/server/wm/DisplayRotation.java index af89a05bfa62..bef80f0a230a 100644 --- a/services/core/java/com/android/server/wm/DisplayRotation.java +++ b/services/core/java/com/android/server/wm/DisplayRotation.java @@ -594,7 +594,8 @@ public class DisplayRotation { // In the presence of the PINNED stack or System Alert windows we unfortunately can not // seamlessly rotate. - if (mDisplayContent.hasPinnedTask() || mDisplayContent.hasAlertWindowSurfaces()) { + if (mDisplayContent.getDefaultTaskDisplayArea().hasPinnedTask() + || mDisplayContent.hasAlertWindowSurfaces()) { return false; } diff --git a/services/core/java/com/android/server/wm/InsetsPolicy.java b/services/core/java/com/android/server/wm/InsetsPolicy.java index 007af249c580..e4e57168efe7 100644 --- a/services/core/java/com/android/server/wm/InsetsPolicy.java +++ b/services/core/java/com/android/server/wm/InsetsPolicy.java @@ -295,10 +295,10 @@ class InsetsPolicy { } private boolean forceShowsSystemBarsForWindowingMode() { - final boolean isDockedStackVisible = - mDisplayContent.isStackVisible(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY); - final boolean isFreeformStackVisible = - mDisplayContent.isStackVisible(WINDOWING_MODE_FREEFORM); + final boolean isDockedStackVisible = mDisplayContent.getDefaultTaskDisplayArea() + .isStackVisible(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY); + final boolean isFreeformStackVisible = mDisplayContent.getDefaultTaskDisplayArea() + .isStackVisible(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 a936e74bf694..57a54d0e84ef 100644 --- a/services/core/java/com/android/server/wm/KeyguardController.java +++ b/services/core/java/com/android/server/wm/KeyguardController.java @@ -406,11 +406,12 @@ class KeyguardController { // show on top of the lock screen. In this can we want to dismiss the docked // stack since it will be complicated/risky to try to put the activity on top // of the lock screen in the right fullscreen configuration. - final DisplayContent display = mRootWindowContainer.getDefaultDisplay(); - if (!display.mTaskContainers.isSplitScreenModeActivated()) { + final TaskDisplayArea taskDisplayArea = mRootWindowContainer + .getDefaultTaskDisplayArea(); + if (!taskDisplayArea.isSplitScreenModeActivated()) { return; } - display.mTaskContainers.onSplitScreenModeDismissed(); + taskDisplayArea.onSplitScreenModeDismissed(); } } diff --git a/services/core/java/com/android/server/wm/PinnedStackController.java b/services/core/java/com/android/server/wm/PinnedStackController.java index 66dbfd5f2a84..02a27410dc38 100644 --- a/services/core/java/com/android/server/wm/PinnedStackController.java +++ b/services/core/java/com/android/server/wm/PinnedStackController.java @@ -286,7 +286,8 @@ class PinnedStackController { } try { final Rect animatingBounds = new Rect(); - final ActivityStack pinnedStack = mDisplayContent.getRootPinnedTask(); + final ActivityStack pinnedStack = mDisplayContent.getDefaultTaskDisplayArea() + .getRootPinnedTask(); if (pinnedStack != null) { pinnedStack.getAnimationOrCurrentBounds(animatingBounds); } diff --git a/services/core/java/com/android/server/wm/RecentsAnimation.java b/services/core/java/com/android/server/wm/RecentsAnimation.java index 08b0abf5e9be..a031fe82d48b 100644 --- a/services/core/java/com/android/server/wm/RecentsAnimation.java +++ b/services/core/java/com/android/server/wm/RecentsAnimation.java @@ -52,14 +52,14 @@ import com.android.server.wm.RecentsAnimationController.RecentsAnimationCallback * cleanup. See {@link com.android.server.wm.RecentsAnimationController}. */ class RecentsAnimation implements RecentsAnimationCallbacks, - DisplayContent.OnStackOrderChangedListener { + TaskDisplayArea.OnStackOrderChangedListener { private static final String TAG = RecentsAnimation.class.getSimpleName(); private final ActivityTaskManagerService mService; private final ActivityStackSupervisor mStackSupervisor; private final ActivityStartController mActivityStartController; private final WindowManagerService mWindowManager; - private final DisplayContent mDefaultDisplay; + private final TaskDisplayArea mDefaultTaskDisplayArea; private final Intent mTargetIntent; private final ComponentName mRecentsComponent; private final @Nullable String mRecentsFeatureId; @@ -84,7 +84,7 @@ class RecentsAnimation implements RecentsAnimationCallbacks, int recentsUid, @Nullable WindowProcessController caller) { mService = atm; mStackSupervisor = stackSupervisor; - mDefaultDisplay = mService.mRootWindowContainer.getDefaultDisplay(); + mDefaultTaskDisplayArea = mService.mRootWindowContainer.getDefaultTaskDisplayArea(); mActivityStartController = activityStartController; mWindowManager = wm; mTargetIntent = targetIntent; @@ -107,7 +107,7 @@ class RecentsAnimation implements RecentsAnimationCallbacks, void preloadRecentsActivity() { ProtoLog.d(WM_DEBUG_RECENTS_ANIMATIONS, "Preload recents with %s", mTargetIntent); - ActivityStack targetStack = mDefaultDisplay.getStack(WINDOWING_MODE_UNDEFINED, + ActivityStack targetStack = mDefaultTaskDisplayArea.getStack(WINDOWING_MODE_UNDEFINED, mTargetActivityType); ActivityRecord targetActivity = getTargetActivity(targetStack); if (targetActivity != null) { @@ -128,7 +128,8 @@ class RecentsAnimation implements RecentsAnimationCallbacks, // Create the activity record. Because the activity is invisible, this doesn't really // start the client. startRecentsActivityInBackground("preloadRecents"); - targetStack = mDefaultDisplay.getStack(WINDOWING_MODE_UNDEFINED, mTargetActivityType); + targetStack = mDefaultTaskDisplayArea.getStack(WINDOWING_MODE_UNDEFINED, + mTargetActivityType); targetActivity = getTargetActivity(targetStack); if (targetActivity == null) { Slog.w(TAG, "Cannot start " + mTargetIntent); @@ -176,12 +177,11 @@ class RecentsAnimation implements RecentsAnimationCallbacks, } // If the activity is associated with the recents stack, then try and get that first - ActivityStack targetStack = mDefaultDisplay.getStack(WINDOWING_MODE_UNDEFINED, + ActivityStack targetStack = mDefaultTaskDisplayArea.getStack(WINDOWING_MODE_UNDEFINED, mTargetActivityType); ActivityRecord targetActivity = getTargetActivity(targetStack); final boolean hasExistingActivity = targetActivity != null; if (hasExistingActivity) { - final TaskDisplayArea taskDisplayArea = targetActivity.getDisplayArea(); mRestoreTargetBehindStack = getStackAbove(targetStack); if (mRestoreTargetBehindStack == null) { notifyAnimationCancelBeforeStart(recentsAnimationRunner); @@ -209,7 +209,7 @@ class RecentsAnimation implements RecentsAnimationCallbacks, try { if (hasExistingActivity) { // Move the recents activity into place for the animation if it is not top most - mDefaultDisplay.mTaskContainers.moveStackBehindBottomMostVisibleStack(targetStack); + mDefaultTaskDisplayArea.moveStackBehindBottomMostVisibleStack(targetStack); ProtoLog.d(WM_DEBUG_RECENTS_ANIMATIONS, "Moved stack=%s behind stack=%s", targetStack, getStackAbove(targetStack)); @@ -225,10 +225,10 @@ class RecentsAnimation implements RecentsAnimationCallbacks, startRecentsActivityInBackground("startRecentsActivity_noTargetActivity"); // Move the recents activity into place for the animation - targetStack = mDefaultDisplay.getStack(WINDOWING_MODE_UNDEFINED, + targetStack = mDefaultTaskDisplayArea.getStack(WINDOWING_MODE_UNDEFINED, mTargetActivityType); targetActivity = getTargetActivity(targetStack); - mDefaultDisplay.mTaskContainers.moveStackBehindBottomMostVisibleStack(targetStack); + mDefaultTaskDisplayArea.moveStackBehindBottomMostVisibleStack(targetStack); ProtoLog.d(WM_DEBUG_RECENTS_ANIMATIONS, "Moved stack=%s behind stack=%s", targetStack, getStackAbove(targetStack)); @@ -251,7 +251,7 @@ class RecentsAnimation implements RecentsAnimationCallbacks, mWindowManager.cancelRecentsAnimation(REORDER_MOVE_TO_ORIGINAL_POSITION, "startRecentsActivity"); mWindowManager.initializeRecentsAnimation(mTargetActivityType, recentsAnimationRunner, - this, mDefaultDisplay.getDisplayId(), + this, mDefaultTaskDisplayArea.getDisplayId(), mStackSupervisor.mRecentTasks.getRecentTaskIds(), targetActivity); // If we updated the launch-behind state, update the visibility of the activities after @@ -262,7 +262,7 @@ class RecentsAnimation implements RecentsAnimationCallbacks, START_TASK_TO_FRONT, targetActivity); // Register for stack order changes - mDefaultDisplay.registerStackOrderChangedListener(this); + mDefaultTaskDisplayArea.registerStackOrderChangedListener(this); } catch (Exception e) { Slog.e(TAG, "Failed to start recents activity", e); throw e; @@ -280,7 +280,7 @@ class RecentsAnimation implements RecentsAnimationCallbacks, mWindowManager.getRecentsAnimationController(), reorderMode); // Unregister for stack order changes - mDefaultDisplay.unregisterStackOrderChangedListener(this); + mDefaultTaskDisplayArea.unregisterStackOrderChangedListener(this); final RecentsAnimationController controller = mWindowManager.getRecentsAnimationController(); @@ -308,7 +308,7 @@ class RecentsAnimation implements RecentsAnimationCallbacks, try { mWindowManager.cleanupRecentsAnimation(reorderMode); - final ActivityStack targetStack = mDefaultDisplay.getStack( + final ActivityStack targetStack = mDefaultTaskDisplayArea.getStack( 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). @@ -422,7 +422,7 @@ class RecentsAnimation implements RecentsAnimationCallbacks, @Override public void onStackOrderChanged(ActivityStack stack) { ProtoLog.d(WM_DEBUG_RECENTS_ANIMATIONS, "onStackOrderChanged(): stack=%s", stack); - if (mDefaultDisplay.getIndexOf(stack) == -1 || !stack.shouldBeVisible(null)) { + if (mDefaultTaskDisplayArea.getIndexOf(stack) == -1 || !stack.shouldBeVisible(null)) { // The stack is not visible, so ignore this change return; } @@ -480,8 +480,8 @@ class RecentsAnimation implements RecentsAnimationCallbacks, * @return The top stack that is not always-on-top. */ private ActivityStack getTopNonAlwaysOnTopStack() { - for (int i = mDefaultDisplay.getStackCount() - 1; i >= 0; i--) { - final ActivityStack s = mDefaultDisplay.getStackAt(i); + for (int i = mDefaultTaskDisplayArea.getStackCount() - 1; i >= 0; i--) { + final ActivityStack s = mDefaultTaskDisplayArea.getStackAt(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 a30b70de267d..84229f003032 100644 --- a/services/core/java/com/android/server/wm/RecentsAnimationController.java +++ b/services/core/java/com/android/server/wm/RecentsAnimationController.java @@ -340,9 +340,11 @@ public class RecentsAnimationController implements DeathRecipient { // Make leashes for each of the visible/target tasks and add it to the recents animation to // be started - final ArrayList<Task> visibleTasks = mDisplayContent.getVisibleTasks(); - final ActivityStack targetStack = mDisplayContent.getStack(WINDOWING_MODE_UNDEFINED, - targetActivityType); + // TODO(multi-display-area): Support Recents on multiple task display areas + final ArrayList<Task> visibleTasks = mDisplayContent.getDefaultTaskDisplayArea() + .getVisibleTasks(); + final ActivityStack targetStack = mDisplayContent.getDefaultTaskDisplayArea() + .getStack(WINDOWING_MODE_UNDEFINED, targetActivityType); if (targetStack != null) { final PooledConsumer c = PooledLambda.obtainConsumer((t, outList) -> { if (!outList.contains(t)) outList.add(t); }, PooledLambda.__(Task.class), @@ -385,7 +387,8 @@ public class RecentsAnimationController implements DeathRecipient { } // Save the minimized home height - mMinimizedHomeBounds = mDisplayContent.getRootHomeTask().getBounds(); + mMinimizedHomeBounds = mDisplayContent.getDefaultTaskDisplayArea().getRootHomeTask() + .getBounds(); mService.mWindowPlacerLocked.performSurfacePlacement(); diff --git a/services/core/java/com/android/server/wm/ResetTargetTaskHelper.java b/services/core/java/com/android/server/wm/ResetTargetTaskHelper.java index 770c08889ab9..32de699eaae9 100644 --- a/services/core/java/com/android/server/wm/ResetTargetTaskHelper.java +++ b/services/core/java/com/android/server/wm/ResetTargetTaskHelper.java @@ -232,10 +232,11 @@ class ResetTargetTaskHelper { } final ActivityTaskManagerService atmService = mTargetStack.mAtmService; - DisplayContent display = mTargetStack.getDisplay(); - final boolean singleTaskInstanceDisplay = display.isSingleTaskInstance(); + TaskDisplayArea taskDisplayArea = mTargetStack.getDisplayArea(); + final boolean singleTaskInstanceDisplay = + taskDisplayArea.mDisplayContent.isSingleTaskInstance(); if (singleTaskInstanceDisplay) { - display = atmService.mRootWindowContainer.getDefaultDisplay(); + taskDisplayArea = atmService.mRootWindowContainer.getDefaultTaskDisplayArea(); } final int windowingMode = mTargetStack.getWindowingMode(); @@ -246,7 +247,7 @@ class ResetTargetTaskHelper { final boolean alwaysCreateTask = DisplayContent.alwaysCreateStack(windowingMode, activityType); final Task task = alwaysCreateTask - ? display.getBottomMostTask() : mTargetStack.getBottomMostTask(); + ? taskDisplayArea.getBottomMostTask() : mTargetStack.getBottomMostTask(); Task targetTask = null; if (task != null && r.taskAffinity.equals(task.affinity)) { // If the activity currently at the bottom has the same task affinity as @@ -257,7 +258,7 @@ class ResetTargetTaskHelper { } if (targetTask == null) { if (alwaysCreateTask) { - targetTask = display.mTaskContainers.getOrCreateStack(windowingMode, + targetTask = taskDisplayArea.getOrCreateStack(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 2764b121cc00..2eeda4dcfeed 100644 --- a/services/core/java/com/android/server/wm/RootWindowContainer.java +++ b/services/core/java/com/android/server/wm/RootWindowContainer.java @@ -1369,11 +1369,11 @@ class RootWindowContainer extends WindowContainer<DisplayContent> } calculateDefaultMinimalSizeOfResizeableTasks(); - final DisplayContent defaultDisplay = getDefaultDisplay(); - - defaultDisplay.mTaskContainers.getOrCreateStack(WINDOWING_MODE_FULLSCREEN, - ACTIVITY_TYPE_HOME, ON_TOP); - positionChildAt(POSITION_TOP, defaultDisplay, false /* includingParents */); + final TaskDisplayArea defaultTaskDisplayArea = getDefaultTaskDisplayArea(); + defaultTaskDisplayArea.getOrCreateStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_HOME, + ON_TOP); + positionChildAt(POSITION_TOP, defaultTaskDisplayArea.mDisplayContent, + false /* includingParents */); } // TODO(multi-display): Look at all callpoints to make sure they make sense in multi-display. @@ -1382,6 +1382,16 @@ class RootWindowContainer extends WindowContainer<DisplayContent> } /** + * Get the default display area on the device dedicated to app windows. This one should be used + * only as a fallback location for activity launches when no target display area is specified, + * or for cases when multi-instance is not supported yet (like Split-screen, Freeform, PiP or + * Recents). + */ + TaskDisplayArea getDefaultTaskDisplayArea() { + return mDefaultDisplay.getDefaultTaskDisplayArea(); + } + + /** * Get an existing instance of {@link DisplayContent} that has the given uniqueId. Unique ID is * defined in {@link DisplayInfo#uniqueId}. * @@ -1436,12 +1446,8 @@ class RootWindowContainer extends WindowContainer<DisplayContent> return displayContent; } - ActivityRecord getDefaultDisplayHomeActivity() { - return getDefaultDisplayHomeActivityForUser(mCurrentUser); - } - ActivityRecord getDefaultDisplayHomeActivityForUser(int userId) { - return getDisplayContent(DEFAULT_DISPLAY).mTaskContainers.getHomeActivityForUser(userId); + return getDefaultTaskDisplayArea().getHomeActivityForUser(userId); } boolean startHomeOnAllDisplays(int userId, String reason) { @@ -1972,8 +1978,8 @@ class RootWindowContainer extends WindowContainer<DisplayContent> final int focusStackId = topFocusedStack != null ? topFocusedStack.getRootTaskId() : INVALID_TASK_ID; // We dismiss the docked stack whenever we switch users. - if (getDefaultDisplay().mTaskContainers.isSplitScreenModeActivated()) { - getDefaultDisplay().mTaskContainers.onSplitScreenModeDismissed(); + if (getDefaultTaskDisplayArea().isSplitScreenModeActivated()) { + getDefaultTaskDisplayArea().onSplitScreenModeDismissed(); } // Also dismiss the pinned stack whenever we switch users. Removing the pinned stack will // also cause all tasks to be moved to the fullscreen stack at a position that is @@ -1995,7 +2001,7 @@ class RootWindowContainer extends WindowContainer<DisplayContent> final int restoreStackId = mUserStackInFront.get(userId); ActivityStack stack = getStack(restoreStackId); if (stack == null) { - stack = getDefaultDisplay().mTaskContainers.getOrCreateRootHomeTask(); + stack = getDefaultTaskDisplayArea().getOrCreateRootHomeTask(); } final boolean homeInFront = stack.isActivityTypeHome(); if (stack.isOnHomeDisplay()) { @@ -2018,7 +2024,7 @@ class RootWindowContainer extends WindowContainer<DisplayContent> void updateUserStack(int userId, ActivityStack stack) { if (userId != mCurrentUser) { if (stack == null) { - stack = getDefaultDisplay().mTaskContainers.getOrCreateRootHomeTask(); + stack = getDefaultTaskDisplayArea().getOrCreateRootHomeTask(); } mUserStackInFront.put(userId, stack.getRootTaskId()); @@ -2061,7 +2067,7 @@ class RootWindowContainer extends WindowContainer<DisplayContent> return; } - stack.reparent(displayContent.mDisplayContent, onTop); + stack.reparent(displayContent.getDefaultTaskDisplayArea(), onTop); // TODO(multi-display): resize stacks properly if moved from split-screen. } @@ -2155,8 +2161,8 @@ class RootWindowContainer extends WindowContainer<DisplayContent> // Looking up task on preferred display first final DisplayContent preferredDisplay = getDisplayContent(preferredDisplayId); if (preferredDisplay != null) { - preferredDisplay.mTaskContainers.findTaskLocked(r, true /* isPreferredDisplay */, - mTmpFindTaskResult); + preferredDisplay.getDefaultTaskDisplayArea().findTaskLocked(r, + true /* isPreferredDisplay */, mTmpFindTaskResult); if (mTmpFindTaskResult.mIdealMatch) { return mTmpFindTaskResult.mRecord; } @@ -2168,7 +2174,7 @@ class RootWindowContainer extends WindowContainer<DisplayContent> continue; } - display.mTaskContainers.findTaskLocked(r, false /* isPreferredDisplay */, + display.getDefaultTaskDisplayArea().findTaskLocked(r, false /* isPreferredDisplay */, mTmpFindTaskResult); if (mTmpFindTaskResult.mIdealMatch) { return mTmpFindTaskResult.mRecord; @@ -2788,8 +2794,10 @@ class RootWindowContainer extends WindowContainer<DisplayContent> } final DisplayContent display = getDisplayContentOrCreate(displayId); if (display != null) { - stack = display.mTaskContainers.getOrCreateStack(r, options, candidateTask, - activityType, onTop); + // Falling back to default task container + final TaskDisplayArea taskDisplayArea = display.getDefaultTaskDisplayArea(); + stack = taskDisplayArea.getOrCreateStack(r, options, candidateTask, activityType, + onTop); if (stack != null) { return stack; } @@ -2835,7 +2843,7 @@ class RootWindowContainer extends WindowContainer<DisplayContent> if (container == null || !canLaunchOnDisplay(r, container.mDisplayContent.mDisplayId)) { - container = getDefaultDisplay().mTaskContainers; + container = getDefaultTaskDisplayArea(); if (windowingMode == WindowConfiguration.WINDOWING_MODE_UNDEFINED) { windowingMode = container.resolveWindowingMode(r, options, candidateTask, activityType); @@ -2887,7 +2895,7 @@ class RootWindowContainer extends WindowContainer<DisplayContent> // it to the target display. if (candidateTask.isRootTask()) { final ActivityStack stack = candidateTask.getStack(); - displayContent.moveStackToDisplay(stack, true /* onTop */); + stack.reparent(displayContent.getDefaultTaskDisplayArea(), true /* onTop */); return stack; } } @@ -2918,7 +2926,8 @@ class RootWindowContainer extends WindowContainer<DisplayContent> final int activityType = options != null && options.getLaunchActivityType() != ACTIVITY_TYPE_UNDEFINED ? options.getLaunchActivityType() : r.getActivityType(); - return displayContent.createStack(windowingMode, activityType, true /*onTop*/); + final TaskDisplayArea taskDisplayArea = displayContent.getDefaultTaskDisplayArea(); + return taskDisplayArea.createStack(windowingMode, activityType, true /*onTop*/); } return null; @@ -2989,7 +2998,8 @@ class RootWindowContainer extends WindowContainer<DisplayContent> if (preferredDisplayArea == null) { // Stack is currently detached because it is being removed. Use the previous display it // was on. - preferredDisplayArea = getDisplayContent(currentFocus.mPrevDisplayId).mTaskContainers; + preferredDisplayArea = getDisplayContent(currentFocus.mPrevDisplayId) + .getDefaultTaskDisplayArea(); } final ActivityStack preferredFocusableStack = preferredDisplayArea.getNextFocusableStack( currentFocus, ignoreCurrent); @@ -3010,7 +3020,7 @@ class RootWindowContainer extends WindowContainer<DisplayContent> // We've already checked this one continue; } - final ActivityStack nextFocusableStack = display.mTaskContainers + final ActivityStack nextFocusableStack = display.getDefaultTaskDisplayArea() .getNextFocusableStack(currentFocus, ignoreCurrent); if (nextFocusableStack != null) { return nextFocusableStack; @@ -3020,31 +3030,6 @@ class RootWindowContainer extends WindowContainer<DisplayContent> return null; } - /** - * Get next valid stack for launching provided activity in the system. This will search across - * displays and stacks in last-focused order for a focusable and visible stack, except those - * that are on a currently focused display. - * - * @param r The activity that is being launched. - * @param currentFocus The display that previously had focus and thus needs to be ignored when - * searching for the next candidate. - * @return Next valid {@link ActivityStack}, null if not found. - */ - ActivityStack getNextValidLaunchStack(@NonNull ActivityRecord r, int currentFocus) { - for (int i = getChildCount() - 1; i >= 0; --i) { - final DisplayContent display = getChildAt(i); - if (display.mDisplayId == currentFocus) { - continue; - } - final ActivityStack stack = getValidLaunchStackOnDisplay(display.mDisplayId, r, - null /* options */, null /* launchParams */); - if (stack != null) { - return stack; - } - } - return null; - } - boolean handleAppDied(WindowProcessController app) { boolean hasVisibleActivities = false; for (int displayNdx = getChildCount() - 1; displayNdx >= 0; --displayNdx) { diff --git a/services/core/java/com/android/server/wm/TaskDisplayArea.java b/services/core/java/com/android/server/wm/TaskDisplayArea.java index 77ef01134292..13e4d8b038b1 100644 --- a/services/core/java/com/android/server/wm/TaskDisplayArea.java +++ b/services/core/java/com/android/server/wm/TaskDisplayArea.java @@ -127,6 +127,12 @@ final class TaskDisplayArea extends DisplayArea<ActivityStack> { * the new stack becomes resumed after which it will be set to current focused stack. */ ActivityStack mLastFocusedStack; + /** + * 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()}. + */ + private ArrayList<OnStackOrderChangedListener> mStackOrderChangedCallbacks = new ArrayList<>(); TaskDisplayArea(DisplayContent displayContent, WindowManagerService service) { super(service, Type.ANY, "TaskContainers", FEATURE_TASK_CONTAINER); @@ -336,9 +342,9 @@ final class TaskDisplayArea extends DisplayArea<ActivityStack> { // Since a stack could be repositioned while being one of the child, return // current index if that's the same stack we are positioning and it is always on // top. - final boolean sameStack = mDisplayContent.getStacks().get(i) == stack; + final boolean sameStack = mChildren.get(i) == stack; if ((sameStack && stack.isAlwaysOnTop()) - || (!sameStack && !mDisplayContent.getStacks().get(i).isAlwaysOnTop())) { + || (!sameStack && !mChildren.get(i).isAlwaysOnTop())) { belowAlwaysOnTopPosition = i; break; } @@ -352,7 +358,7 @@ final class TaskDisplayArea extends DisplayArea<ActivityStack> { if (stack.isAlwaysOnTop()) { if (hasPinnedTask()) { // Always-on-top stacks go below the pinned stack. - maxPosition = mDisplayContent.getStacks().indexOf(mRootPinnedTask) - 1; + maxPosition = mChildren.indexOf(mRootPinnedTask) - 1; } // Always-on-top stacks need to be above all other stacks. minPosition = belowAlwaysOnTopPosition @@ -375,7 +381,7 @@ final class TaskDisplayArea extends DisplayArea<ActivityStack> { targetPosition = Math.min(targetPosition, maxPosition); targetPosition = Math.max(targetPosition, minPosition); - int prevPosition = mDisplayContent.getStacks().indexOf(stack); + int prevPosition = mChildren.indexOf(stack); // 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". @@ -471,7 +477,7 @@ final class TaskDisplayArea extends DisplayArea<ActivityStack> { @Override int getOrientation(int candidate) { - if (mDisplayContent.isStackVisible(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY)) { + if (isStackVisible(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. @@ -637,7 +643,7 @@ final class TaskDisplayArea extends DisplayArea<ActivityStack> { mPreferredTopFocusableStack = null; } mDisplayContent.releaseSelfIfNeeded(); - mDisplayContent.onStackOrderChanged(stack); + onStackOrderChanged(stack); } void positionStackAt(int position, ActivityStack child, boolean includingParents) { @@ -716,7 +722,7 @@ final class TaskDisplayArea extends DisplayArea<ActivityStack> { } } - mDisplayContent.onStackOrderChanged(stack); + onStackOrderChanged(stack); } ActivityStack getStack(int rootTaskId) { @@ -765,11 +771,11 @@ final class TaskDisplayArea extends DisplayArea<ActivityStack> { } else if (stack.getParent() != launchRootTask) { stack.reparent(launchRootTask, position); } - } else if (stack.getDisplay() != mDisplayContent || !stack.isRootTask()) { + } else if (stack.getDisplayArea() != this || !stack.isRootTask()) { if (stack.getParent() == null) { addStack(stack, position); } else { - stack.reparent(mDisplayContent, onTop); + stack.reparent(this, onTop); } } // Update windowing mode if necessary, e.g. moving a pinned task to fullscreen. @@ -832,7 +838,7 @@ final class TaskDisplayArea extends DisplayArea<ActivityStack> { // Create stack on default display instead since this display can only contain 1 stack. // TODO: Kinda a hack, but better that having the decision at each call point. Hoping // this goes away once ActivityView is no longer using virtual displays. - return mRootWindowContainer.getDefaultDisplay().mTaskContainers.createStack( + return mRootWindowContainer.getDefaultTaskDisplayArea().createStack( windowingMode, activityType, onTop, info, intent, createdByOrganizer); } @@ -1551,6 +1557,16 @@ final class TaskDisplayArea extends DisplayArea<ActivityStack> { return (index < wc.mChildren.size()) ? (ActivityStack) wc.mChildren.get(index) : null; } + /** Returns true if the stack in the windowing mode is visible. */ + boolean isStackVisible(int windowingMode) { + final ActivityStack stack = getTopStackInWindowingMode(windowingMode); + return stack != null && stack.isVisible(); + } + + void removeStack(ActivityStack stack) { + removeChild(stack); + } + int getDisplayId() { return mDisplayContent.getDisplayId(); } @@ -1558,4 +1574,39 @@ final class TaskDisplayArea extends DisplayArea<ActivityStack> { boolean isRemoved() { return mDisplayContent.isRemoved(); } + + /** + * Adds a listener to be notified whenever the stack order in the display changes. Currently + * 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); + } + } + + /** + * Removes a previously registered stack order change listener. + */ + void unregisterStackOrderChangedListener(OnStackOrderChangedListener listener) { + mStackOrderChangedCallbacks.remove(listener); + } + + /** + * Notifies of a stack order change + * @param stack The stack which triggered the order change + */ + void onStackOrderChanged(ActivityStack stack) { + for (int i = mStackOrderChangedCallbacks.size() - 1; i >= 0; i--) { + mStackOrderChangedCallbacks.get(i).onStackOrderChanged(stack); + } + } + + /** + * Callback for when the order of the stacks in the display changes. + */ + interface OnStackOrderChangedListener { + void onStackOrderChanged(ActivityStack stack); + } } diff --git a/services/core/java/com/android/server/wm/TaskOrganizerController.java b/services/core/java/com/android/server/wm/TaskOrganizerController.java index b641e4c391ce..9ffd8d244c75 100644 --- a/services/core/java/com/android/server/wm/TaskOrganizerController.java +++ b/services/core/java/com/android/server/wm/TaskOrganizerController.java @@ -277,7 +277,7 @@ class TaskOrganizerController extends ITaskOrganizerController.Stub { return null; } - final Task task = display.mTaskContainers.createStack(windowingMode, + final Task task = display.getDefaultTaskDisplayArea().createStack(windowingMode, ACTIVITY_TYPE_UNDEFINED, false /* onTop */, null /* info */, new Intent(), true /* createdByOrganizer */); RunningTaskInfo out = task.getTaskInfo(); diff --git a/services/core/java/com/android/server/wm/WallpaperController.java b/services/core/java/com/android/server/wm/WallpaperController.java index e43f4b485349..b9b6c0858031 100644 --- a/services/core/java/com/android/server/wm/WallpaperController.java +++ b/services/core/java/com/android/server/wm/WallpaperController.java @@ -510,7 +510,7 @@ class WallpaperController { private void findWallpaperTarget() { mFindResults.reset(); - if (mDisplayContent.isStackVisible(WINDOWING_MODE_FREEFORM)) { + if (mDisplayContent.getDefaultTaskDisplayArea().isStackVisible(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 dfaa0ec47155..687af64e9d4f 100644 --- a/services/core/java/com/android/server/wm/WindowManagerService.java +++ b/services/core/java/com/android/server/wm/WindowManagerService.java @@ -7318,8 +7318,9 @@ public class WindowManagerService extends IWindowManager.Stub @Override public boolean isStackVisibleLw(int windowingMode) { - final DisplayContent dc = getDefaultDisplayContentLocked(); - return dc.isStackVisible(windowingMode); + // TODO(multi-display-area): Support multiple task display areas & displays + final TaskDisplayArea tc = mRoot.getDefaultTaskDisplayArea(); + return tc.isStackVisible(windowingMode); } @Override diff --git a/services/core/java/com/android/server/wm/WindowOrganizerController.java b/services/core/java/com/android/server/wm/WindowOrganizerController.java index a332b6966291..3e2e9be24c4f 100644 --- a/services/core/java/com/android/server/wm/WindowOrganizerController.java +++ b/services/core/java/com/android/server/wm/WindowOrganizerController.java @@ -234,7 +234,7 @@ class WindowOrganizerController extends IWindowOrganizerController.Stub if (task.getParent() != newParent) { if (newParent == null) { // Re-parent task to display as a root task. - dc.moveStackToDisplay(as, hop.getToTop()); + as.reparent(dc.getDefaultTaskDisplayArea(), hop.getToTop()); } else if (newParent.inMultiWindowMode() && !task.isResizeable() && task.isLeafTask()) { Slog.w(TAG, "Can't support task that doesn't support multi-window mode in" diff --git a/services/core/java/com/android/server/wm/WindowState.java b/services/core/java/com/android/server/wm/WindowState.java index b87d18143fc7..8e7585ae4bfa 100644 --- a/services/core/java/com/android/server/wm/WindowState.java +++ b/services/core/java/com/android/server/wm/WindowState.java @@ -1516,7 +1516,8 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP // Some system windows (e.g. "Power off" dialog) don't have a task, but we would still // associate them with some stack to enable dimming. final DisplayContent dc = getDisplayContent(); - return mAttrs.type >= FIRST_SYSTEM_WINDOW && dc != null ? dc.getRootHomeTask() : null; + return mAttrs.type >= FIRST_SYSTEM_WINDOW + && dc != null ? dc.getDefaultTaskDisplayArea().getRootHomeTask() : null; } /** diff --git a/services/core/java/com/android/server/wm/WindowToken.java b/services/core/java/com/android/server/wm/WindowToken.java index 3c2b6ec9711d..7457a1d05335 100644 --- a/services/core/java/com/android/server/wm/WindowToken.java +++ b/services/core/java/com/android/server/wm/WindowToken.java @@ -397,7 +397,8 @@ class WindowToken extends WindowContainer<WindowState> { void assignLayer(SurfaceControl.Transaction t, int layer) { if (windowType == TYPE_DOCK_DIVIDER) { // See {@link DisplayContent#mSplitScreenDividerAnchor} - super.assignRelativeLayer(t, mDisplayContent.getSplitScreenDividerAnchor(), 1); + super.assignRelativeLayer(t, + mDisplayContent.getDefaultTaskDisplayArea().getSplitScreenDividerAnchor(), 1); } else if (mRoundedCornerOverlay) { super.assignLayer(t, WindowManagerPolicy.COLOR_FADE_LAYER + 1); } else { 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 05604b2b9aeb..1debd8c9ffb1 100644 --- a/services/tests/wmtests/src/com/android/server/wm/ActivityDisplayTests.java +++ b/services/tests/wmtests/src/com/android/server/wm/ActivityDisplayTests.java @@ -61,19 +61,20 @@ public class ActivityDisplayTests extends ActivityTestsBase { @Test public void testLastFocusedStackIsUpdatedWhenMovingStack() { // Create a stack at bottom. - final DisplayContent display = mRootWindowContainer.getDefaultDisplay(); + final TaskDisplayArea taskDisplayAreas = + mRootWindowContainer.getDefaultDisplay().getDefaultTaskDisplayArea(); final ActivityStack stack = new StackBuilder(mRootWindowContainer).setOnTop(!ON_TOP).build(); - final ActivityStack prevFocusedStack = display.getFocusedStack(); + final ActivityStack prevFocusedStack = taskDisplayAreas.getFocusedStack(); stack.moveToFront("moveStackToFront"); // After moving the stack to front, the previous focused should be the last focused. assertTrue(stack.isFocusedStackOnDisplay()); - assertEquals(prevFocusedStack, display.mTaskContainers.getLastFocusedStack()); + assertEquals(prevFocusedStack, taskDisplayAreas.getLastFocusedStack()); stack.moveToBack("moveStackToBack", null /* task */); // After moving the stack to back, the stack should be the last focused. - assertEquals(stack, display.mTaskContainers.getLastFocusedStack()); + assertEquals(stack, taskDisplayAreas.getLastFocusedStack()); } /** @@ -83,8 +84,8 @@ public class ActivityDisplayTests extends ActivityTestsBase { @Test public void testFullscreenStackCanBeFocusedWhenFocusablePinnedStackExists() { // Create a pinned stack and move to front. - final ActivityStack pinnedStack = mRootWindowContainer.getDefaultDisplay().createStack( - WINDOWING_MODE_PINNED, ACTIVITY_TYPE_STANDARD, ON_TOP); + final ActivityStack pinnedStack = mRootWindowContainer.getDefaultTaskDisplayArea() + .createStack(WINDOWING_MODE_PINNED, ACTIVITY_TYPE_STANDARD, ON_TOP); final Task pinnedTask = new TaskBuilder(mService.mStackSupervisor) .setStack(pinnedStack).build(); new ActivityBuilder(mService).setActivityFlags(FLAG_ALWAYS_FOCUSABLE) @@ -104,8 +105,8 @@ public class ActivityDisplayTests extends ActivityTestsBase { } /** - * Test {@link DisplayContent#mPreferredTopFocusableStack} will be cleared when the stack is - * removed or moved to back, and the focused stack will be according to z-order. + * Test {@link TaskDisplayArea#mPreferredTopFocusableStack} will be cleared when + * the stack is removed or moved to back, and the focused stack will be according to z-order. */ @Test public void testStackShouldNotBeFocusedAfterMovingToBackOrRemoving() { @@ -124,7 +125,7 @@ public class ActivityDisplayTests extends ActivityTestsBase { assertTrue(stack1.isFocusedStackOnDisplay()); // Stack2 should be focused after removing stack1. - display.removeStack(stack1); + stack1.getDisplayArea().removeStack(stack1); assertTrue(stack2.isFocusedStackOnDisplay()); } @@ -156,7 +157,7 @@ public class ActivityDisplayTests extends ActivityTestsBase { } private ActivityStack createFullscreenStackWithSimpleActivityAt(DisplayContent display) { - final ActivityStack fullscreenStack = display.createStack( + final ActivityStack fullscreenStack = display.getDefaultTaskDisplayArea().createStack( WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, ON_TOP); final Task fullscreenTask = new TaskBuilder(mService.mStackSupervisor) .setStack(fullscreenStack).build(); @@ -219,58 +220,56 @@ public class ActivityDisplayTests extends ActivityTestsBase { */ @Test public void testAlwaysOnTopStackLocation() { - final DisplayContent display = mRootWindowContainer.getDefaultDisplay(); - final ActivityStack alwaysOnTopStack = display.createStack(WINDOWING_MODE_FREEFORM, + final TaskDisplayArea taskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea(); + final ActivityStack alwaysOnTopStack = taskDisplayArea.createStack(WINDOWING_MODE_FREEFORM, ACTIVITY_TYPE_STANDARD, true /* onTop */); final ActivityRecord activity = new ActivityBuilder(mService).setCreateTask(true) .setStack(alwaysOnTopStack).build(); alwaysOnTopStack.setAlwaysOnTop(true); - display.mTaskContainers.positionStackAtTop(alwaysOnTopStack, false /* includingParents */); + taskDisplayArea.positionStackAtTop(alwaysOnTopStack, false /* includingParents */); assertTrue(alwaysOnTopStack.isAlwaysOnTop()); // Ensure always on top state is synced to the children of the stack. assertTrue(alwaysOnTopStack.getTopNonFinishingActivity().isAlwaysOnTop()); - assertEquals(alwaysOnTopStack, display.getTopStack()); + assertEquals(alwaysOnTopStack, taskDisplayArea.getTopStack()); - final ActivityStack pinnedStack = display.createStack( + final ActivityStack pinnedStack = taskDisplayArea.createStack( WINDOWING_MODE_PINNED, ACTIVITY_TYPE_STANDARD, true /* onTop */); - assertEquals(pinnedStack, display.getRootPinnedTask()); - assertEquals(pinnedStack, display.getTopStack()); + assertEquals(pinnedStack, taskDisplayArea.getRootPinnedTask()); + assertEquals(pinnedStack, taskDisplayArea.getTopStack()); - final ActivityStack anotherAlwaysOnTopStack = display.createStack( + final ActivityStack anotherAlwaysOnTopStack = taskDisplayArea.createStack( WINDOWING_MODE_FREEFORM, ACTIVITY_TYPE_STANDARD, true /* onTop */); anotherAlwaysOnTopStack.setAlwaysOnTop(true); - display.mTaskContainers.positionStackAtTop(anotherAlwaysOnTopStack, - false /* includingParents */); + taskDisplayArea.positionStackAtTop(anotherAlwaysOnTopStack, false /* includingParents */); assertTrue(anotherAlwaysOnTopStack.isAlwaysOnTop()); - int topPosition = display.getStackCount() - 1; + int topPosition = taskDisplayArea.getStackCount() - 1; // Ensure the new alwaysOnTop stack is put below the pinned stack, but on top of the // existing alwaysOnTop stack. - assertEquals(anotherAlwaysOnTopStack, display.getStackAt(topPosition - 1)); + assertEquals(anotherAlwaysOnTopStack, taskDisplayArea.getStackAt(topPosition - 1)); - final ActivityStack nonAlwaysOnTopStack = display.createStack( + final ActivityStack nonAlwaysOnTopStack = taskDisplayArea.createStack( WINDOWING_MODE_FREEFORM, ACTIVITY_TYPE_STANDARD, true /* onTop */); - assertEquals(display, nonAlwaysOnTopStack.getDisplay()); - topPosition = display.getStackCount() - 1; + assertEquals(taskDisplayArea, nonAlwaysOnTopStack.getDisplayArea()); + topPosition = taskDisplayArea.getStackCount() - 1; // Ensure the non-alwaysOnTop stack is put below the three alwaysOnTop stacks, but above the // existing other non-alwaysOnTop stacks. - assertEquals(nonAlwaysOnTopStack, display.getStackAt(topPosition - 3)); + assertEquals(nonAlwaysOnTopStack, taskDisplayArea.getStackAt(topPosition - 3)); anotherAlwaysOnTopStack.setAlwaysOnTop(false); - display.mTaskContainers.positionStackAtTop(anotherAlwaysOnTopStack, - false /* includingParents */); + taskDisplayArea.positionStackAtTop(anotherAlwaysOnTopStack, false /* includingParents */); 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, display.getStackAt(topPosition - 2)); + assertEquals(anotherAlwaysOnTopStack, taskDisplayArea.getStackAt(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, display.getStackAt(topPosition - 2)); + assertEquals(anotherAlwaysOnTopStack, taskDisplayArea.getStackAt(topPosition - 2)); anotherAlwaysOnTopStack.setWindowingMode(WINDOWING_MODE_FREEFORM); assertTrue(anotherAlwaysOnTopStack.isAlwaysOnTop()); - assertEquals(anotherAlwaysOnTopStack, display.getStackAt(topPosition - 1)); + assertEquals(anotherAlwaysOnTopStack, taskDisplayArea.getStackAt(topPosition - 1)); } @Test @@ -286,14 +285,14 @@ public class ActivityDisplayTests extends ActivityTestsBase { } private void removeStackTests(Runnable runnable) { - final DisplayContent display = mRootWindowContainer.getDefaultDisplay(); - final ActivityStack stack1 = display.createStack(WINDOWING_MODE_FULLSCREEN, + final TaskDisplayArea taskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea(); + final ActivityStack stack1 = taskDisplayArea.createStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, ON_TOP); - final ActivityStack stack2 = display.createStack(WINDOWING_MODE_FULLSCREEN, + final ActivityStack stack2 = taskDisplayArea.createStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, ON_TOP); - final ActivityStack stack3 = display.createStack(WINDOWING_MODE_FULLSCREEN, + final ActivityStack stack3 = taskDisplayArea.createStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, ON_TOP); - final ActivityStack stack4 = display.createStack(WINDOWING_MODE_FULLSCREEN, + final ActivityStack stack4 = taskDisplayArea.createStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, ON_TOP); final Task task1 = new TaskBuilder(mService.mStackSupervisor).setStack(stack1).build(); final Task task2 = new TaskBuilder(mService.mStackSupervisor).setStack(stack2).build(); @@ -302,13 +301,13 @@ public class ActivityDisplayTests extends ActivityTestsBase { // Reordering stacks while removing stacks. doAnswer(invocation -> { - display.mTaskContainers.positionStackAtTop(stack3, false); + taskDisplayArea.positionStackAtTop(stack3, false); return true; }).when(mSupervisor).removeTask(eq(task4), anyBoolean(), anyBoolean(), any()); // Removing stacks from the display while removing stacks. doAnswer(invocation -> { - display.removeStack(stack2); + taskDisplayArea.removeStack(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 cff93cf8ef1d..08f6409cb902 100644 --- a/services/tests/wmtests/src/com/android/server/wm/ActivityRecordTests.java +++ b/services/tests/wmtests/src/com/android/server/wm/ActivityRecordTests.java @@ -1400,8 +1400,8 @@ public class ActivityRecordTests extends ActivityTestsBase { display = new TestDisplayContent.Builder(mService, 2000, 1000).setDensityDpi(300) .setPosition(DisplayContent.POSITION_TOP).build(); } - final ActivityStack stack = display.createStack(WINDOWING_MODE_UNDEFINED, - ACTIVITY_TYPE_STANDARD, true /* onTop */); + final ActivityStack stack = display.getDefaultTaskDisplayArea() + .createStack(WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_STANDARD, true /* onTop */); final Task task = new TaskBuilder(mSupervisor).setStack(stack).build(); return new ActivityBuilder(mService).setTask(task).setUseProcess(process).build(); } diff --git a/services/tests/wmtests/src/com/android/server/wm/ActivityStackSupervisorTests.java b/services/tests/wmtests/src/com/android/server/wm/ActivityStackSupervisorTests.java index e8c0362c9f32..22d7fcbb4162 100644 --- a/services/tests/wmtests/src/com/android/server/wm/ActivityStackSupervisorTests.java +++ b/services/tests/wmtests/src/com/android/server/wm/ActivityStackSupervisorTests.java @@ -60,7 +60,7 @@ public class ActivityStackSupervisorTests extends ActivityTestsBase { @Before public void setUp() throws Exception { - mFullscreenStack = mRootWindowContainer.getDefaultDisplay().createStack( + mFullscreenStack = mRootWindowContainer.getDefaultTaskDisplayArea().createStack( WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */); } 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 af5afff4bed1..3d15401cdfb9 100644 --- a/services/tests/wmtests/src/com/android/server/wm/ActivityStackTests.java +++ b/services/tests/wmtests/src/com/android/server/wm/ActivityStackTests.java @@ -82,15 +82,15 @@ import org.junit.runner.RunWith; @Presubmit @RunWith(WindowTestRunner.class) public class ActivityStackTests extends ActivityTestsBase { - private DisplayContent mDefaultDisplay; + private TaskDisplayArea mDefaultTaskDisplayArea; private ActivityStack mStack; private Task mTask; @Before public void setUp() throws Exception { - mDefaultDisplay = mRootWindowContainer.getDefaultDisplay(); - mStack = mDefaultDisplay.createStack(WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_STANDARD, - true /* onTop */); + mDefaultTaskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea(); + mStack = mDefaultTaskDisplayArea.createStack(WINDOWING_MODE_UNDEFINED, + ACTIVITY_TYPE_STANDARD, true /* onTop */); spyOn(mStack); mTask = new TaskBuilder(mSupervisor).setStack(mStack).build(); } @@ -112,7 +112,7 @@ public class ActivityStackTests extends ActivityTestsBase { r.setState(RESUMED, "testResumedActivityFromTaskReparenting"); assertEquals(r, mStack.getResumedActivity()); - final ActivityStack destStack = mRootWindowContainer.getDefaultDisplay().createStack( + final ActivityStack destStack = mDefaultTaskDisplayArea.createStack( WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */); mTask.reparent(destStack, true /* toTop */, Task.REPARENT_KEEP_STACK_AT_FRONT, @@ -130,7 +130,7 @@ public class ActivityStackTests extends ActivityTestsBase { r.setState(RESUMED, "testResumedActivityFromActivityReparenting"); assertEquals(r, mStack.getResumedActivity()); - final ActivityStack destStack = mRootWindowContainer.getDefaultDisplay().createStack( + final ActivityStack destStack = mDefaultTaskDisplayArea.createStack( WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */); mTask.reparent(destStack, true /*toTop*/, REPARENT_MOVE_STACK_TO_FRONT, false, false, "testResumedActivityFromActivityReparenting"); @@ -143,7 +143,7 @@ public class ActivityStackTests extends ActivityTestsBase { public void testPrimarySplitScreenRestoresWhenMovedToBack() { // Create primary splitscreen stack. This will create secondary stacks and places the // existing fullscreen stack on the bottom. - final ActivityStack primarySplitScreen = mDefaultDisplay.createStack( + final ActivityStack primarySplitScreen = mDefaultTaskDisplayArea.createStack( WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, ACTIVITY_TYPE_STANDARD, true /* onTop */); // Assert windowing mode. @@ -154,7 +154,7 @@ public class ActivityStackTests extends ActivityTestsBase { null /* task */); // Assert that stack is at the bottom. - assertEquals(0, mDefaultDisplay.getIndexOf(primarySplitScreen)); + assertEquals(0, mDefaultTaskDisplayArea.getIndexOf(primarySplitScreen)); // Ensure no longer in splitscreen. assertEquals(WINDOWING_MODE_FULLSCREEN, primarySplitScreen.getWindowingMode()); @@ -167,7 +167,7 @@ public class ActivityStackTests extends ActivityTestsBase { @Test public void testPrimarySplitScreenRestoresPreviousWhenMovedToBack() { // This time, start with a fullscreen activitystack - final ActivityStack primarySplitScreen = mDefaultDisplay.createStack( + final ActivityStack primarySplitScreen = mDefaultTaskDisplayArea.createStack( WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */); primarySplitScreen.setWindowingMode(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY); @@ -180,7 +180,7 @@ public class ActivityStackTests extends ActivityTestsBase { null /* task */); // Assert that stack is at the bottom. - assertEquals(0, mDefaultDisplay.getIndexOf(primarySplitScreen)); + assertEquals(0, mDefaultTaskDisplayArea.getIndexOf(primarySplitScreen)); // Ensure that the override mode is restored to what it was (fullscreen) assertEquals(WINDOWING_MODE_FULLSCREEN, @@ -189,14 +189,14 @@ public class ActivityStackTests extends ActivityTestsBase { @Test public void testStackInheritsDisplayWindowingMode() { - final ActivityStack primarySplitScreen = mDefaultDisplay.createStack( + final ActivityStack primarySplitScreen = mDefaultTaskDisplayArea.createStack( WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_STANDARD, true /* onTop */); assertEquals(WINDOWING_MODE_FULLSCREEN, primarySplitScreen.getWindowingMode()); assertEquals(WINDOWING_MODE_UNDEFINED, primarySplitScreen.getRequestedOverrideWindowingMode()); - mDefaultDisplay.setWindowingMode(WINDOWING_MODE_FREEFORM); + mDefaultTaskDisplayArea.setWindowingMode(WINDOWING_MODE_FREEFORM); assertEquals(WINDOWING_MODE_FREEFORM, primarySplitScreen.getWindowingMode()); assertEquals(WINDOWING_MODE_UNDEFINED, primarySplitScreen.getRequestedOverrideWindowingMode()); @@ -204,7 +204,7 @@ public class ActivityStackTests extends ActivityTestsBase { @Test public void testStackOverridesDisplayWindowingMode() { - final ActivityStack primarySplitScreen = mDefaultDisplay.createStack( + final ActivityStack primarySplitScreen = mDefaultTaskDisplayArea.createStack( WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_STANDARD, true /* onTop */); assertEquals(WINDOWING_MODE_FULLSCREEN, primarySplitScreen.getWindowingMode()); @@ -216,7 +216,7 @@ public class ActivityStackTests extends ActivityTestsBase { assertEquals(WINDOWING_MODE_FULLSCREEN, primarySplitScreen.getRequestedOverrideWindowingMode()); - mDefaultDisplay.setWindowingMode(WINDOWING_MODE_FREEFORM); + mDefaultTaskDisplayArea.setWindowingMode(WINDOWING_MODE_FREEFORM); assertEquals(WINDOWING_MODE_FULLSCREEN, primarySplitScreen.getWindowingMode()); } @@ -283,10 +283,11 @@ public class ActivityStackTests extends ActivityTestsBase { @Test public void testMoveStackToBackIncludingParent() { - final DisplayContent display = addNewDisplayContentAt(DisplayContent.POSITION_TOP); - final ActivityStack stack1 = createStackForShouldBeVisibleTest(display, + final TaskDisplayArea taskDisplayArea = addNewDisplayContentAt(DisplayContent.POSITION_TOP) + .getDefaultTaskDisplayArea(); + final ActivityStack stack1 = createStackForShouldBeVisibleTest(taskDisplayArea, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */); - final ActivityStack stack2 = createStackForShouldBeVisibleTest(display, + final ActivityStack stack2 = createStackForShouldBeVisibleTest(taskDisplayArea, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */); // Do not move display to back because there is still another stack. @@ -294,16 +295,16 @@ public class ActivityStackTests extends ActivityTestsBase { verify(stack2).positionChildAtBottom(any(), eq(false) /* includingParents */); // Also move display to back because there is only one stack left. - display.removeStack(stack1); + taskDisplayArea.removeStack(stack1); stack2.moveToBack("testMoveStackToBackIncludingParent", stack2.getTopMostTask()); verify(stack2).positionChildAtBottom(any(), eq(true) /* includingParents */); } @Test public void testShouldBeVisible_Fullscreen() { - final ActivityStack homeStack = createStackForShouldBeVisibleTest(mDefaultDisplay, + final ActivityStack homeStack = createStackForShouldBeVisibleTest(mDefaultTaskDisplayArea, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_HOME, true /* onTop */); - final ActivityStack pinnedStack = createStackForShouldBeVisibleTest(mDefaultDisplay, + final ActivityStack pinnedStack = createStackForShouldBeVisibleTest(mDefaultTaskDisplayArea, WINDOWING_MODE_PINNED, ACTIVITY_TYPE_STANDARD, true /* onTop */); // Add an activity to the pinned stack so it isn't considered empty for visibility check. final ActivityRecord pinnedActivity = new ActivityBuilder(mService) @@ -314,8 +315,9 @@ public class ActivityStackTests extends ActivityTestsBase { assertTrue(homeStack.shouldBeVisible(null /* starting */)); assertTrue(pinnedStack.shouldBeVisible(null /* starting */)); - final ActivityStack fullscreenStack = createStackForShouldBeVisibleTest(mDefaultDisplay, - WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */); + final ActivityStack fullscreenStack = createStackForShouldBeVisibleTest( + mDefaultTaskDisplayArea, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, + true /* onTop */); // Home stack shouldn't be visible behind an opaque fullscreen stack, but pinned stack // should be visible since it is always on-top. doReturn(false).when(fullscreenStack).isTranslucent(any()); @@ -331,15 +333,15 @@ public class ActivityStackTests extends ActivityTestsBase { @Test public void testShouldBeVisible_SplitScreen() { - final ActivityStack homeStack = createStackForShouldBeVisibleTest(mDefaultDisplay, + final ActivityStack homeStack = createStackForShouldBeVisibleTest(mDefaultTaskDisplayArea, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_HOME, true /* onTop */); // Home stack should always be fullscreen for this test. doReturn(false).when(homeStack).supportsSplitScreenWindowingMode(); final ActivityStack splitScreenPrimary = - createStackForShouldBeVisibleTest(mDefaultDisplay, + createStackForShouldBeVisibleTest(mDefaultTaskDisplayArea, WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, ACTIVITY_TYPE_STANDARD, true /* onTop */); final ActivityStack splitScreenSecondary = - createStackForShouldBeVisibleTest(mDefaultDisplay, + createStackForShouldBeVisibleTest(mDefaultTaskDisplayArea, WINDOWING_MODE_SPLIT_SCREEN_SECONDARY, ACTIVITY_TYPE_STANDARD, true /* onTop */); // Home stack shouldn't be visible if both halves of split-screen are opaque. @@ -367,7 +369,7 @@ public class ActivityStackTests extends ActivityTestsBase { splitScreenSecondary.getVisibility(null /* starting */)); final ActivityStack splitScreenSecondary2 = - createStackForShouldBeVisibleTest(mDefaultDisplay, + createStackForShouldBeVisibleTest(mDefaultTaskDisplayArea, WINDOWING_MODE_SPLIT_SCREEN_SECONDARY, ACTIVITY_TYPE_STANDARD, true /* onTop */); // First split-screen secondary shouldn't be visible behind another opaque split-split // secondary. @@ -389,8 +391,9 @@ public class ActivityStackTests extends ActivityTestsBase { assertEquals(STACK_VISIBILITY_VISIBLE, splitScreenSecondary2.getVisibility(null /* starting */)); - final ActivityStack assistantStack = createStackForShouldBeVisibleTest(mDefaultDisplay, - WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_ASSISTANT, true /* onTop */); + final ActivityStack assistantStack = createStackForShouldBeVisibleTest( + mDefaultTaskDisplayArea, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_ASSISTANT, + true /* onTop */); // Split-screen stacks shouldn't be visible behind an opaque fullscreen stack. doReturn(false).when(assistantStack).isTranslucent(any()); @@ -530,7 +533,7 @@ public class ActivityStackTests extends ActivityTestsBase { final ActivityStack translucentStack = createStandardStackForVisibilityTest(WINDOWING_MODE_FULLSCREEN, true /* translucent */); - final ActivityStack pinnedStack = createStackForShouldBeVisibleTest(mDefaultDisplay, + final ActivityStack pinnedStack = createStackForShouldBeVisibleTest(mDefaultTaskDisplayArea, WINDOWING_MODE_PINNED, ACTIVITY_TYPE_STANDARD, true /* onTop */); assertEquals(STACK_VISIBILITY_VISIBLE_BEHIND_TRANSLUCENT, @@ -547,7 +550,7 @@ public class ActivityStackTests extends ActivityTestsBase { @Test public void testShouldBeVisible_Finishing() { - final ActivityStack homeStack = createStackForShouldBeVisibleTest(mDefaultDisplay, + final ActivityStack homeStack = createStackForShouldBeVisibleTest(mDefaultTaskDisplayArea, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_HOME, true /* onTop */); ActivityRecord topRunningHomeActivity = homeStack.topRunningActivity(); if (topRunningHomeActivity == null) { @@ -558,7 +561,7 @@ public class ActivityStackTests extends ActivityTestsBase { } final ActivityStack translucentStack = createStackForShouldBeVisibleTest( - mDefaultDisplay, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, + mDefaultTaskDisplayArea, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */); doReturn(true).when(translucentStack).isTranslucent(any()); @@ -580,7 +583,7 @@ public class ActivityStackTests extends ActivityTestsBase { @Test public void testShouldBeVisible_FullscreenBehindTranslucentInHomeStack() { - final ActivityStack homeStack = createStackForShouldBeVisibleTest(mDefaultDisplay, + final ActivityStack homeStack = createStackForShouldBeVisibleTest(mDefaultTaskDisplayArea, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_HOME, true /* onTop */); final ActivityRecord firstActivity = new ActivityBuilder(mService) @@ -601,74 +604,77 @@ public class ActivityStackTests extends ActivityTestsBase { @Test public void testMoveHomeStackBehindBottomMostVisibleStack_NoMoveHomeBehindFullscreen() { - mDefaultDisplay.removeStack(mStack); + mDefaultTaskDisplayArea.removeStack(mStack); - final ActivityStack homeStack = createStackForShouldBeVisibleTest(mDefaultDisplay, + final ActivityStack homeStack = createStackForShouldBeVisibleTest(mDefaultTaskDisplayArea, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_HOME, true /* onTop */); - final ActivityStack fullscreenStack = createStackForShouldBeVisibleTest(mDefaultDisplay, - WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */); + final ActivityStack fullscreenStack = createStackForShouldBeVisibleTest( + mDefaultTaskDisplayArea, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, + true /* onTop */); doReturn(false).when(homeStack).isTranslucent(any()); doReturn(false).when(fullscreenStack).isTranslucent(any()); // Ensure that we don't move the home stack if it is already behind the top fullscreen stack - int homeStackIndex = mDefaultDisplay.getIndexOf(homeStack); + int homeStackIndex = mDefaultTaskDisplayArea.getIndexOf(homeStack); assertEquals(fullscreenStack, getStackAbove(homeStack)); - mDefaultDisplay.mTaskContainers.moveStackBehindBottomMostVisibleStack(homeStack); - assertEquals(homeStackIndex, mDefaultDisplay.getIndexOf(homeStack)); + mDefaultTaskDisplayArea.moveStackBehindBottomMostVisibleStack(homeStack); + assertEquals(homeStackIndex, mDefaultTaskDisplayArea.getIndexOf(homeStack)); } @Test public void testMoveHomeStackBehindBottomMostVisibleStack_NoMoveHomeBehindTranslucent() { - mDefaultDisplay.removeStack(mStack); + mDefaultTaskDisplayArea.removeStack(mStack); - final ActivityStack homeStack = createStackForShouldBeVisibleTest(mDefaultDisplay, + final ActivityStack homeStack = createStackForShouldBeVisibleTest(mDefaultTaskDisplayArea, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_HOME, true /* onTop */); - final ActivityStack fullscreenStack = createStackForShouldBeVisibleTest(mDefaultDisplay, + final ActivityStack fullscreenStack = createStackForShouldBeVisibleTest( + mDefaultTaskDisplayArea, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */); doReturn(false).when(homeStack).isTranslucent(any()); doReturn(true).when(fullscreenStack).isTranslucent(any()); // Ensure that we don't move the home stack if it is already behind the top fullscreen stack - int homeStackIndex = mDefaultDisplay.getIndexOf(homeStack); + int homeStackIndex = mDefaultTaskDisplayArea.getIndexOf(homeStack); assertEquals(fullscreenStack, getStackAbove(homeStack)); - mDefaultDisplay.mTaskContainers.moveStackBehindBottomMostVisibleStack(homeStack); - assertEquals(homeStackIndex, mDefaultDisplay.getIndexOf(homeStack)); + mDefaultTaskDisplayArea.moveStackBehindBottomMostVisibleStack(homeStack); + assertEquals(homeStackIndex, mDefaultTaskDisplayArea.getIndexOf(homeStack)); } @Test public void testMoveHomeStackBehindBottomMostVisibleStack_NoMoveHomeOnTop() { - mDefaultDisplay.removeStack(mStack); + mDefaultTaskDisplayArea.removeStack(mStack); - final ActivityStack fullscreenStack = createStackForShouldBeVisibleTest(mDefaultDisplay, - WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */); - final ActivityStack homeStack = createStackForShouldBeVisibleTest(mDefaultDisplay, + final ActivityStack fullscreenStack = createStackForShouldBeVisibleTest( + mDefaultTaskDisplayArea, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, + true /* onTop */); + final ActivityStack homeStack = createStackForShouldBeVisibleTest(mDefaultTaskDisplayArea, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_HOME, true /* onTop */); doReturn(false).when(homeStack).isTranslucent(any()); doReturn(false).when(fullscreenStack).isTranslucent(any()); // Ensure we don't move the home stack if it is already on top - int homeStackIndex = mDefaultDisplay.getIndexOf(homeStack); + int homeStackIndex = mDefaultTaskDisplayArea.getIndexOf(homeStack); assertNull(getStackAbove(homeStack)); - mDefaultDisplay.mTaskContainers.moveStackBehindBottomMostVisibleStack(homeStack); - assertEquals(homeStackIndex, mDefaultDisplay.getIndexOf(homeStack)); + mDefaultTaskDisplayArea.moveStackBehindBottomMostVisibleStack(homeStack); + assertEquals(homeStackIndex, mDefaultTaskDisplayArea.getIndexOf(homeStack)); } @Test public void testMoveHomeStackBehindBottomMostVisibleStack_MoveHomeBehindFullscreen() { - mDefaultDisplay.removeStack(mStack); + mDefaultTaskDisplayArea.removeStack(mStack); - final ActivityStack homeStack = createStackForShouldBeVisibleTest(mDefaultDisplay, + final ActivityStack homeStack = createStackForShouldBeVisibleTest(mDefaultTaskDisplayArea, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_HOME, true /* onTop */); final ActivityStack fullscreenStack1 = createStackForShouldBeVisibleTest( - mDefaultDisplay, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, + mDefaultTaskDisplayArea, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */); final ActivityStack fullscreenStack2 = createStackForShouldBeVisibleTest( - mDefaultDisplay, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, + mDefaultTaskDisplayArea, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */); - final ActivityStack pinnedStack = createStackForShouldBeVisibleTest(mDefaultDisplay, + final ActivityStack pinnedStack = createStackForShouldBeVisibleTest(mDefaultTaskDisplayArea, WINDOWING_MODE_PINNED, ACTIVITY_TYPE_STANDARD, true /* onTop */); doReturn(false).when(homeStack).isTranslucent(any()); @@ -678,22 +684,22 @@ public class ActivityStackTests extends ActivityTestsBase { // Ensure that we move the home stack behind the bottom most fullscreen stack, ignoring the // pinned stack assertEquals(fullscreenStack1, getStackAbove(homeStack)); - mDefaultDisplay.mTaskContainers.moveStackBehindBottomMostVisibleStack(homeStack); + mDefaultTaskDisplayArea.moveStackBehindBottomMostVisibleStack(homeStack); assertEquals(fullscreenStack2, getStackAbove(homeStack)); } @Test public void testMoveHomeStackBehindBottomMostVisibleStack_MoveHomeBehindFullscreenAndTranslucent() { - mDefaultDisplay.removeStack(mStack); + mDefaultTaskDisplayArea.removeStack(mStack); - final ActivityStack homeStack = createStackForShouldBeVisibleTest(mDefaultDisplay, + final ActivityStack homeStack = createStackForShouldBeVisibleTest(mDefaultTaskDisplayArea, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_HOME, true /* onTop */); final ActivityStack fullscreenStack1 = createStackForShouldBeVisibleTest( - mDefaultDisplay, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, + mDefaultTaskDisplayArea, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */); final ActivityStack fullscreenStack2 = createStackForShouldBeVisibleTest( - mDefaultDisplay, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, + mDefaultTaskDisplayArea, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */); doReturn(false).when(homeStack).isTranslucent(any()); @@ -703,21 +709,21 @@ public class ActivityStackTests extends ActivityTestsBase { // Ensure that we move the home stack behind the bottom most non-translucent fullscreen // stack assertEquals(fullscreenStack1, getStackAbove(homeStack)); - mDefaultDisplay.mTaskContainers.moveStackBehindBottomMostVisibleStack(homeStack); + mDefaultTaskDisplayArea.moveStackBehindBottomMostVisibleStack(homeStack); assertEquals(fullscreenStack1, getStackAbove(homeStack)); } @Test public void testMoveHomeStackBehindStack_BehindHomeStack() { - mDefaultDisplay.removeStack(mStack); + mDefaultTaskDisplayArea.removeStack(mStack); final ActivityStack fullscreenStack1 = createStackForShouldBeVisibleTest( - mDefaultDisplay, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, + mDefaultTaskDisplayArea, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */); final ActivityStack fullscreenStack2 = createStackForShouldBeVisibleTest( - mDefaultDisplay, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, + mDefaultTaskDisplayArea, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */); - final ActivityStack homeStack = createStackForShouldBeVisibleTest(mDefaultDisplay, + final ActivityStack homeStack = createStackForShouldBeVisibleTest(mDefaultTaskDisplayArea, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_HOME, true /* onTop */); doReturn(false).when(homeStack).isTranslucent(any()); @@ -725,50 +731,50 @@ public class ActivityStackTests extends ActivityTestsBase { doReturn(false).when(fullscreenStack2).isTranslucent(any()); // Ensure we don't move the home stack behind itself - int homeStackIndex = mDefaultDisplay.getIndexOf(homeStack); - mDefaultDisplay.mTaskContainers.moveStackBehindStack(homeStack, homeStack); - assertEquals(homeStackIndex, mDefaultDisplay.getIndexOf(homeStack)); + int homeStackIndex = mDefaultTaskDisplayArea.getIndexOf(homeStack); + mDefaultTaskDisplayArea.moveStackBehindStack(homeStack, homeStack); + assertEquals(homeStackIndex, mDefaultTaskDisplayArea.getIndexOf(homeStack)); } @Test public void testMoveHomeStackBehindStack() { - mDefaultDisplay.removeStack(mStack); + mDefaultTaskDisplayArea.removeStack(mStack); final ActivityStack fullscreenStack1 = createStackForShouldBeVisibleTest( - mDefaultDisplay, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, + mDefaultTaskDisplayArea, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */); final ActivityStack fullscreenStack2 = createStackForShouldBeVisibleTest( - mDefaultDisplay, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, + mDefaultTaskDisplayArea, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */); final ActivityStack fullscreenStack3 = createStackForShouldBeVisibleTest( - mDefaultDisplay, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, + mDefaultTaskDisplayArea, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */); final ActivityStack fullscreenStack4 = createStackForShouldBeVisibleTest( - mDefaultDisplay, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, + mDefaultTaskDisplayArea, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */); - final ActivityStack homeStack = createStackForShouldBeVisibleTest(mDefaultDisplay, + final ActivityStack homeStack = createStackForShouldBeVisibleTest(mDefaultTaskDisplayArea, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_HOME, true /* onTop */); - mDefaultDisplay.mTaskContainers.moveStackBehindStack(homeStack, fullscreenStack1); + mDefaultTaskDisplayArea.moveStackBehindStack(homeStack, fullscreenStack1); assertEquals(fullscreenStack1, getStackAbove(homeStack)); - mDefaultDisplay.mTaskContainers.moveStackBehindStack(homeStack, fullscreenStack2); + mDefaultTaskDisplayArea.moveStackBehindStack(homeStack, fullscreenStack2); assertEquals(fullscreenStack2, getStackAbove(homeStack)); - mDefaultDisplay.mTaskContainers.moveStackBehindStack(homeStack, fullscreenStack4); + mDefaultTaskDisplayArea.moveStackBehindStack(homeStack, fullscreenStack4); assertEquals(fullscreenStack4, getStackAbove(homeStack)); - mDefaultDisplay.mTaskContainers.moveStackBehindStack(homeStack, fullscreenStack2); + mDefaultTaskDisplayArea.moveStackBehindStack(homeStack, fullscreenStack2); assertEquals(fullscreenStack2, getStackAbove(homeStack)); } @Test public void testSetAlwaysOnTop() { - final ActivityStack homeStack = createStackForShouldBeVisibleTest(mDefaultDisplay, + final ActivityStack homeStack = createStackForShouldBeVisibleTest(mDefaultTaskDisplayArea, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_HOME, true /* onTop */); - final ActivityStack pinnedStack = createStackForShouldBeVisibleTest(mDefaultDisplay, + final ActivityStack pinnedStack = createStackForShouldBeVisibleTest(mDefaultTaskDisplayArea, WINDOWING_MODE_PINNED, ACTIVITY_TYPE_STANDARD, true /* onTop */); assertEquals(pinnedStack, getStackAbove(homeStack)); final ActivityStack alwaysOnTopStack = createStackForShouldBeVisibleTest( - mDefaultDisplay, WINDOWING_MODE_FREEFORM, ACTIVITY_TYPE_STANDARD, + mDefaultTaskDisplayArea, WINDOWING_MODE_FREEFORM, ACTIVITY_TYPE_STANDARD, true /* onTop */); alwaysOnTopStack.setAlwaysOnTop(true); assertTrue(alwaysOnTopStack.isAlwaysOnTop()); @@ -776,13 +782,13 @@ public class ActivityStackTests extends ActivityTestsBase { assertEquals(pinnedStack, getStackAbove(alwaysOnTopStack)); final ActivityStack nonAlwaysOnTopStack = createStackForShouldBeVisibleTest( - mDefaultDisplay, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, + 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)); final ActivityStack alwaysOnTopStack2 = createStackForShouldBeVisibleTest( - mDefaultDisplay, WINDOWING_MODE_FREEFORM, ACTIVITY_TYPE_STANDARD, + mDefaultTaskDisplayArea, WINDOWING_MODE_FREEFORM, ACTIVITY_TYPE_STANDARD, true /* onTop */); alwaysOnTopStack2.setAlwaysOnTop(true); assertTrue(alwaysOnTopStack2.isAlwaysOnTop()); @@ -807,13 +813,14 @@ public class ActivityStackTests extends ActivityTestsBase { @Test public void testSplitScreenMoveToFront() { final ActivityStack splitScreenPrimary = createStackForShouldBeVisibleTest( - mDefaultDisplay, WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, ACTIVITY_TYPE_STANDARD, - true /* onTop */); + mDefaultTaskDisplayArea, WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, + ACTIVITY_TYPE_STANDARD, true /* onTop */); final ActivityStack splitScreenSecondary = createStackForShouldBeVisibleTest( - mDefaultDisplay, WINDOWING_MODE_SPLIT_SCREEN_SECONDARY, ACTIVITY_TYPE_STANDARD, + mDefaultTaskDisplayArea, WINDOWING_MODE_SPLIT_SCREEN_SECONDARY, + ACTIVITY_TYPE_STANDARD, true /* onTop */); + final ActivityStack assistantStack = createStackForShouldBeVisibleTest( + mDefaultTaskDisplayArea, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_ASSISTANT, true /* onTop */); - final ActivityStack assistantStack = createStackForShouldBeVisibleTest(mDefaultDisplay, - WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_ASSISTANT, true /* onTop */); doReturn(false).when(splitScreenPrimary).isTranslucent(any()); doReturn(false).when(splitScreenSecondary).isTranslucent(any()); @@ -832,7 +839,7 @@ public class ActivityStackTests extends ActivityTestsBase { private ActivityStack createStandardStackForVisibilityTest(int windowingMode, boolean translucent) { - final ActivityStack stack = createStackForShouldBeVisibleTest(mDefaultDisplay, + final ActivityStack stack = createStackForShouldBeVisibleTest(mDefaultTaskDisplayArea, windowingMode, ACTIVITY_TYPE_STANDARD, true /* onTop */); doReturn(translucent).when(stack).isTranslucent(any()); return stack; @@ -840,20 +847,20 @@ public class ActivityStackTests extends ActivityTestsBase { @SuppressWarnings("TypeParameterUnusedInFormals") private ActivityStack createStackForShouldBeVisibleTest( - DisplayContent display, int windowingMode, int activityType, boolean onTop) { + TaskDisplayArea taskDisplayArea, int windowingMode, int activityType, boolean onTop) { final ActivityStack stack; if (activityType == ACTIVITY_TYPE_HOME) { // Home stack and activity are created in ActivityTestsBase#setupActivityManagerService - stack = mDefaultDisplay.getStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_HOME); + stack = mDefaultTaskDisplayArea.getStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_HOME); if (onTop) { - mDefaultDisplay.mTaskContainers.positionStackAtTop(stack, + mDefaultTaskDisplayArea.positionStackAtTop(stack, false /* includingParents */); } else { - mDefaultDisplay.mTaskContainers.positionStackAtBottom(stack); + mDefaultTaskDisplayArea.positionStackAtBottom(stack); } } else { stack = new StackBuilder(mRootWindowContainer) - .setDisplay(display) + .setTaskDisplayArea(taskDisplayArea) .setWindowingMode(windowingMode) .setActivityType(activityType) .setOnTop(onTop) @@ -1005,7 +1012,7 @@ public class ActivityStackTests extends ActivityTestsBase { @Test public void testWontFinishHomeStackImmediately() { - final ActivityStack homeStack = createStackForShouldBeVisibleTest(mDefaultDisplay, + final ActivityStack homeStack = createStackForShouldBeVisibleTest(mDefaultTaskDisplayArea, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_HOME, true /* onTop */); ActivityRecord activity = homeStack.topRunningActivity(); @@ -1025,9 +1032,11 @@ public class ActivityStackTests extends ActivityTestsBase { public void testFinishCurrentActivity() { // Create 2 activities on a new display. final DisplayContent display = addNewDisplayContentAt(DisplayContent.POSITION_TOP); - final ActivityStack stack1 = createStackForShouldBeVisibleTest(display, + final ActivityStack stack1 = createStackForShouldBeVisibleTest( + display.getDefaultTaskDisplayArea(), WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */); - final ActivityStack stack2 = createStackForShouldBeVisibleTest(display, + final ActivityStack stack2 = createStackForShouldBeVisibleTest( + display.getDefaultTaskDisplayArea(), WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */); // There is still an activity1 in stack1 so the activity2 should be added to finishing list @@ -1075,26 +1084,26 @@ public class ActivityStackTests extends ActivityTestsBase { @Test public void testStackOrderChangedOnRemoveStack() { StackOrderChangedListener listener = new StackOrderChangedListener(); - mDefaultDisplay.registerStackOrderChangedListener(listener); + mDefaultTaskDisplayArea.registerStackOrderChangedListener(listener); try { - mDefaultDisplay.removeStack(mStack); + mDefaultTaskDisplayArea.removeStack(mStack); } finally { - mDefaultDisplay.unregisterStackOrderChangedListener(listener); + mDefaultTaskDisplayArea.unregisterStackOrderChangedListener(listener); } assertTrue(listener.mChanged); } @Test public void testStackOrderChangedOnAddPositionStack() { - mDefaultDisplay.removeStack(mStack); + mDefaultTaskDisplayArea.removeStack(mStack); StackOrderChangedListener listener = new StackOrderChangedListener(); - mDefaultDisplay.registerStackOrderChangedListener(listener); + mDefaultTaskDisplayArea.registerStackOrderChangedListener(listener); try { mStack.mReparenting = true; - mDefaultDisplay.mTaskContainers.addStack(mStack, 0); + mDefaultTaskDisplayArea.addStack(mStack, 0); } finally { - mDefaultDisplay.unregisterStackOrderChangedListener(listener); + mDefaultTaskDisplayArea.unregisterStackOrderChangedListener(listener); } assertTrue(listener.mChanged); } @@ -1104,12 +1113,12 @@ public class ActivityStackTests extends ActivityTestsBase { StackOrderChangedListener listener = new StackOrderChangedListener(); try { final ActivityStack fullscreenStack1 = createStackForShouldBeVisibleTest( - mDefaultDisplay, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, + mDefaultTaskDisplayArea, WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */); - mDefaultDisplay.registerStackOrderChangedListener(listener); - mDefaultDisplay.mTaskContainers.positionStackAtBottom(fullscreenStack1); + mDefaultTaskDisplayArea.registerStackOrderChangedListener(listener); + mDefaultTaskDisplayArea.positionStackAtBottom(fullscreenStack1); } finally { - mDefaultDisplay.unregisterStackOrderChangedListener(listener); + mDefaultTaskDisplayArea.unregisterStackOrderChangedListener(listener); } assertTrue(listener.mChanged); } @@ -1189,7 +1198,7 @@ public class ActivityStackTests extends ActivityTestsBase { @Test public void testClearUnknownAppVisibilityBehindFullscreenActivity() { final UnknownAppVisibilityController unknownAppVisibilityController = - mDefaultDisplay.mDisplayContent.mUnknownAppVisibilityController; + mDefaultTaskDisplayArea.mDisplayContent.mUnknownAppVisibilityController; final KeyguardController keyguardController = mSupervisor.getKeyguardController(); doReturn(true).when(keyguardController).isKeyguardLocked(); @@ -1254,7 +1263,7 @@ public class ActivityStackTests extends ActivityTestsBase { } private static class StackOrderChangedListener - implements DisplayContent.OnStackOrderChangedListener { + implements TaskDisplayArea.OnStackOrderChangedListener { public boolean mChanged = false; @Override 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 76a761ce0e10..27782f5b3683 100644 --- a/services/tests/wmtests/src/com/android/server/wm/ActivityStartControllerTests.java +++ b/services/tests/wmtests/src/com/android/server/wm/ActivityStartControllerTests.java @@ -77,8 +77,8 @@ public class ActivityStartControllerTests extends ActivityTestsBase { .setCreateTask(true) .build(); final int startFlags = random.nextInt(); - final ActivityStack stack = mService.mRootWindowContainer.getDefaultDisplay().createStack( - WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */); + final ActivityStack stack = mService.mRootWindowContainer.getDefaultTaskDisplayArea() + .createStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */); final WindowProcessController wpc = new WindowProcessController(mService, mService.mContext.getApplicationInfo(), "name", 12345, UserHandle.getUserId(12345), mock(Object.class), 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 1d952bfcef2a..1cca207d5336 100644 --- a/services/tests/wmtests/src/com/android/server/wm/ActivityStarterTests.java +++ b/services/tests/wmtests/src/com/android/server/wm/ActivityStarterTests.java @@ -326,8 +326,9 @@ public class ActivityStarterTests extends ActivityTestsBase { if (mockGetLaunchStack) { // Instrument the stack and task used. - final ActivityStack stack = mRootWindowContainer.getDefaultDisplay().createStack( - WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */); + final ActivityStack stack = mRootWindowContainer.getDefaultTaskDisplayArea() + .createStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, + true /* onTop */); // Direct starter to use spy stack. doReturn(stack).when(mRootWindowContainer) @@ -742,7 +743,7 @@ public class ActivityStarterTests extends ActivityTestsBase { final TestDisplayContent secondaryDisplay = new TestDisplayContent.Builder(mService, 1000, 1500) .setPosition(POSITION_BOTTOM).build(); - final TaskDisplayArea secondaryTaskContainer = secondaryDisplay.mTaskContainers; + final TaskDisplayArea secondaryTaskContainer = secondaryDisplay.getDefaultTaskDisplayArea(); final ActivityStack stack = secondaryTaskContainer.createStack( WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */); @@ -783,7 +784,7 @@ public class ActivityStarterTests extends ActivityTestsBase { new TestDisplayContent.Builder(mService, 1000, 1500).build(); mRootWindowContainer.positionChildAt(POSITION_TOP, secondaryDisplay, false /* includingParents */); - final TaskDisplayArea secondaryTaskContainer = secondaryDisplay.mTaskContainers; + final TaskDisplayArea secondaryTaskContainer = secondaryDisplay.getDefaultTaskDisplayArea(); final ActivityRecord singleTaskActivity = createSingleTaskActivityOn( secondaryTaskContainer.createStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, false /* onTop */)); @@ -835,7 +836,7 @@ public class ActivityStarterTests extends ActivityTestsBase { // Create a secondary display at bottom. final TestDisplayContent secondaryDisplay = addNewDisplayContentAt(POSITION_BOTTOM); - final TaskDisplayArea secondaryTaskContainer = secondaryDisplay.mTaskContainers; + final TaskDisplayArea secondaryTaskContainer = secondaryDisplay.getDefaultTaskDisplayArea(); secondaryTaskContainer.createStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */); @@ -951,7 +952,7 @@ public class ActivityStarterTests extends ActivityTestsBase { final ActivityStarter starter = prepareStarter(0 /* flags */); starter.mStartActivity = new ActivityBuilder(mService).build(); final Task task = new TaskBuilder(mService.mStackSupervisor) - .setStack(mService.mRootWindowContainer.getDefaultDisplay().createStack( + .setStack(mService.mRootWindowContainer.getDefaultTaskDisplayArea().createStack( WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */)) .setUserId(10) .build(); diff --git a/services/tests/wmtests/src/com/android/server/wm/ActivityTestsBase.java b/services/tests/wmtests/src/com/android/server/wm/ActivityTestsBase.java index 9240b2222cd6..67d4769522b0 100644 --- a/services/tests/wmtests/src/com/android/server/wm/ActivityTestsBase.java +++ b/services/tests/wmtests/src/com/android/server/wm/ActivityTestsBase.java @@ -372,7 +372,7 @@ class ActivityTestsBase extends SystemServiceTestsBase { Task build() { if (mStack == null && mCreateStack) { - mStack = mSupervisor.mRootWindowContainer.getDefaultDisplay().createStack( + mStack = mSupervisor.mRootWindowContainer.getDefaultTaskDisplayArea().createStack( WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */); spyOn(mStack); } @@ -408,6 +408,7 @@ class ActivityTestsBase extends SystemServiceTestsBase { static class StackBuilder { private final RootWindowContainer mRootWindowContainer; private DisplayContent mDisplay; + private TaskDisplayArea mTaskDisplayArea; private int mStackId = -1; private int mWindowingMode = WINDOWING_MODE_UNDEFINED; private int mActivityType = ACTIVITY_TYPE_STANDARD; @@ -419,6 +420,7 @@ class ActivityTestsBase extends SystemServiceTestsBase { StackBuilder(RootWindowContainer root) { mRootWindowContainer = root; mDisplay = mRootWindowContainer.getDefaultDisplay(); + mTaskDisplayArea = mDisplay.getDefaultTaskDisplayArea(); } StackBuilder setWindowingMode(int windowingMode) { @@ -436,8 +438,20 @@ class ActivityTestsBase extends SystemServiceTestsBase { return this; } + /** + * Set the parent {@link DisplayContent} and use the default task display area. Overrides + * the task display area, if was set before. + */ StackBuilder setDisplay(DisplayContent display) { mDisplay = display; + mTaskDisplayArea = mDisplay.getDefaultTaskDisplayArea(); + return this; + } + + /** Set the parent {@link TaskDisplayArea}. Overrides the display, if was set before. */ + StackBuilder setTaskDisplayArea(TaskDisplayArea taskDisplayArea) { + mTaskDisplayArea = taskDisplayArea; + mDisplay = mTaskDisplayArea.mDisplayContent; return this; } @@ -462,9 +476,8 @@ class ActivityTestsBase extends SystemServiceTestsBase { } ActivityStack build() { - final int stackId = mStackId >= 0 ? mStackId - : mDisplay.mTaskContainers.getNextStackId(); - final ActivityStack stack = mDisplay.mTaskContainers.createStackUnchecked( + final int stackId = mStackId >= 0 ? mStackId : mTaskDisplayArea.getNextStackId(); + final ActivityStack stack = mTaskDisplayArea.createStackUnchecked( mWindowingMode, mActivityType, stackId, mOnTop, mInfo, mIntent, false /* createdByOrganizer */); final ActivityStackSupervisor supervisor = mRootWindowContainer.mStackSupervisor; diff --git a/services/tests/wmtests/src/com/android/server/wm/AppChangeTransitionTests.java b/services/tests/wmtests/src/com/android/server/wm/AppChangeTransitionTests.java index 4cb50c7a9e4d..9b7ffd69da15 100644 --- a/services/tests/wmtests/src/com/android/server/wm/AppChangeTransitionTests.java +++ b/services/tests/wmtests/src/com/android/server/wm/AppChangeTransitionTests.java @@ -147,7 +147,7 @@ public class AppChangeTransitionTests extends WindowTestsBase { // Reparenting to a display with different windowing mode may trigger // a change transition internally, but it should be cleaned-up once // the display change is complete. - mStack.reparent(mDisplayContent, true); + mStack.reparent(mDisplayContent.getDefaultTaskDisplayArea(), true); assertEquals(WINDOWING_MODE_FULLSCREEN, mTask.getWindowingMode()); diff --git a/services/tests/wmtests/src/com/android/server/wm/AppTransitionTests.java b/services/tests/wmtests/src/com/android/server/wm/AppTransitionTests.java index 8b91c7e5d5f3..8c8fd0516623 100644 --- a/services/tests/wmtests/src/com/android/server/wm/AppTransitionTests.java +++ b/services/tests/wmtests/src/com/android/server/wm/AppTransitionTests.java @@ -169,7 +169,7 @@ public class AppTransitionTests extends WindowTestsBase { assertTrue(dc1.mOpeningApps.size() > 0); // Move stack to another display. - stack1.reparent(dc2, true); + stack1.reparent(dc2.getDefaultTaskDisplayArea(), true); // Verify if token are cleared from both pending transition list in former display. assertFalse(dc1.mOpeningApps.contains(activity1)); 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 38b3d76b447d..a901d1ebd890 100644 --- a/services/tests/wmtests/src/com/android/server/wm/DisplayContentTests.java +++ b/services/tests/wmtests/src/com/android/server/wm/DisplayContentTests.java @@ -281,7 +281,7 @@ public class DisplayContentTests extends WindowTestsBase { assertEquals(dc, activity.getDisplayContent()); // Move stack to first display. - mDisplayContent.moveStackToDisplay(stack, true /* onTop */); + stack.reparent(mDisplayContent.getDefaultTaskDisplayArea(), true /* onTop */); assertEquals(mDisplayContent.getDisplayId(), stack.getDisplayContent().getDisplayId()); assertEquals(mDisplayContent, stack.getDisplayContent()); assertEquals(mDisplayContent, task.getDisplayContent()); @@ -753,7 +753,7 @@ public class DisplayContentTests extends WindowTestsBase { doReturn(true).when(freeformStack).isVisible(); freeformStack.getTopChild().setBounds(100, 100, 300, 400); - assertTrue(dc.isStackVisible(WINDOWING_MODE_FREEFORM)); + assertTrue(dc.getDefaultTaskDisplayArea().isStackVisible(WINDOWING_MODE_FREEFORM)); freeformStack.getTopNonFinishingActivity().setOrientation(SCREEN_ORIENTATION_LANDSCAPE); stack.getTopNonFinishingActivity().setOrientation(SCREEN_ORIENTATION_PORTRAIT); @@ -1096,8 +1096,7 @@ public class DisplayContentTests extends WindowTestsBase { @Test public void testGetOrCreateRootHomeTask_defaultDisplay() { - DisplayContent defaultDisplay = mWm.mRoot.getDisplayContent(DEFAULT_DISPLAY); - TaskDisplayArea defaultTaskDisplayArea = defaultDisplay.mTaskContainers; + TaskDisplayArea defaultTaskDisplayArea = mWm.mRoot.getDefaultTaskDisplayArea(); // Remove the current home stack if it exists so a new one can be created below. ActivityStack homeTask = defaultTaskDisplayArea.getRootHomeTask(); @@ -1116,7 +1115,7 @@ public class DisplayContentTests extends WindowTestsBase { doReturn(false).when(display).isUntrustedVirtualDisplay(); // Remove the current home stack if it exists so a new one can be created below. - TaskDisplayArea taskDisplayArea = display.mTaskContainers; + TaskDisplayArea taskDisplayArea = display.getDefaultTaskDisplayArea(); ActivityStack homeTask = taskDisplayArea.getRootHomeTask(); if (homeTask != null) { taskDisplayArea.removeChild(homeTask); @@ -1129,7 +1128,7 @@ public class DisplayContentTests extends WindowTestsBase { @Test public void testGetOrCreateRootHomeTask_unsupportedSystemDecorations() { DisplayContent display = createNewDisplay(); - TaskDisplayArea taskDisplayArea = display.mTaskContainers; + TaskDisplayArea taskDisplayArea = display.getDefaultTaskDisplayArea(); doReturn(false).when(display).supportsSystemDecorations(); assertNull(taskDisplayArea.getRootHomeTask()); @@ -1139,7 +1138,7 @@ public class DisplayContentTests extends WindowTestsBase { @Test public void testGetOrCreateRootHomeTask_untrustedVirtualDisplay() { DisplayContent display = createNewDisplay(); - TaskDisplayArea taskDisplayArea = display.mTaskContainers; + TaskDisplayArea taskDisplayArea = display.getDefaultTaskDisplayArea(); doReturn(true).when(display).isUntrustedVirtualDisplay(); assertNull(taskDisplayArea.getRootHomeTask()); diff --git a/services/tests/wmtests/src/com/android/server/wm/DisplayRotationTests.java b/services/tests/wmtests/src/com/android/server/wm/DisplayRotationTests.java index cf7411e67135..9b2a2db5d3a8 100644 --- a/services/tests/wmtests/src/com/android/server/wm/DisplayRotationTests.java +++ b/services/tests/wmtests/src/com/android/server/wm/DisplayRotationTests.java @@ -860,6 +860,8 @@ public class DisplayRotationTests { mMockDisplayContent.isDefaultDisplay = mIsDefaultDisplay; when(mMockDisplayContent.calculateDisplayCutoutForRotation(anyInt())) .thenReturn(WmDisplayCutout.NO_CUTOUT); + when(mMockDisplayContent.getDefaultTaskDisplayArea()) + .thenReturn(mock(TaskDisplayArea.class)); mMockDisplayPolicy = mock(DisplayPolicy.class); 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 ae467c0c811d..6a71a7dd24dd 100644 --- a/services/tests/wmtests/src/com/android/server/wm/LaunchParamsPersisterTests.java +++ b/services/tests/wmtests/src/com/android/server/wm/LaunchParamsPersisterTests.java @@ -114,8 +114,8 @@ public class LaunchParamsPersisterTests extends ActivityTestsBase { when(mRootWindowContainer.getDisplayContent(eq(mDisplayUniqueId))) .thenReturn(mTestDisplay); - ActivityStack stack = mTestDisplay.createStack(TEST_WINDOWING_MODE, - ACTIVITY_TYPE_STANDARD, /* onTop */ true); + ActivityStack stack = mTestDisplay.getDefaultTaskDisplayArea() + .createStack(TEST_WINDOWING_MODE, ACTIVITY_TYPE_STANDARD, /* onTop */ true); mTestTask = new TaskBuilder(mSupervisor).setComponent(TEST_COMPONENT).setStack(stack) .build(); mTestTask.mUserId = TEST_USER_ID; @@ -337,8 +337,8 @@ public class LaunchParamsPersisterTests extends ActivityTestsBase { public void testClearsRecordsOfTheUserOnUserCleanUp() { mTarget.saveTask(mTestTask); - ActivityStack stack = mTestDisplay.createStack(TEST_WINDOWING_MODE, - ACTIVITY_TYPE_STANDARD, /* onTop */ true); + ActivityStack stack = mTestDisplay.getDefaultTaskDisplayArea().createStack( + TEST_WINDOWING_MODE, ACTIVITY_TYPE_STANDARD, /* onTop */ true); final Task anotherTaskOfTheSameUser = new TaskBuilder(mSupervisor) .setComponent(ALTERNATIVE_COMPONENT) .setUserId(TEST_USER_ID) @@ -349,7 +349,7 @@ public class LaunchParamsPersisterTests extends ActivityTestsBase { anotherTaskOfTheSameUser.setHasBeenVisible(true); mTarget.saveTask(anotherTaskOfTheSameUser); - stack = mTestDisplay.createStack(TEST_WINDOWING_MODE, + stack = mTestDisplay.getDefaultTaskDisplayArea().createStack(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 071386fa9cbd..d9c3ace4589d 100644 --- a/services/tests/wmtests/src/com/android/server/wm/RecentTasksTest.java +++ b/services/tests/wmtests/src/com/android/server/wm/RecentTasksTest.java @@ -28,7 +28,6 @@ import static android.content.Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS; import static android.content.Intent.FLAG_ACTIVITY_MULTIPLE_TASK; import static android.content.Intent.FLAG_ACTIVITY_NEW_DOCUMENT; import static android.content.Intent.FLAG_ACTIVITY_NEW_TASK; -import static android.view.Display.DEFAULT_DISPLAY; import static com.android.dx.mockito.inline.extended.ExtendedMockito.doNothing; import static com.android.dx.mockito.inline.extended.ExtendedMockito.doReturn; @@ -119,7 +118,7 @@ public class RecentTasksTest extends ActivityTestsBase { public void setUp() throws Exception { mTaskPersister = new TestTaskPersister(mContext.getFilesDir()); spyOn(mTaskPersister); - mTaskContainer = mRootWindowContainer.getDisplayContent(DEFAULT_DISPLAY).mTaskContainers; + mTaskContainer = mRootWindowContainer.getDefaultTaskDisplayArea(); // Set the recent tasks we should use for testing in this class. mRecentTasks = new TestRecentTasks(mService, mTaskPersister); diff --git a/services/tests/wmtests/src/com/android/server/wm/RecentsAnimationControllerTest.java b/services/tests/wmtests/src/com/android/server/wm/RecentsAnimationControllerTest.java index da07baca3ce1..6d2b7b1e86fe 100644 --- a/services/tests/wmtests/src/com/android/server/wm/RecentsAnimationControllerTest.java +++ b/services/tests/wmtests/src/com/android/server/wm/RecentsAnimationControllerTest.java @@ -105,7 +105,7 @@ public class RecentsAnimationControllerTest extends WindowTestsBase { mDefaultDisplay = mWm.mRoot.getDefaultDisplay(); mController = spy(new RecentsAnimationController(mWm, mMockRunner, mAnimationCallbacks, DEFAULT_DISPLAY)); - mRootHomeTask = mDefaultDisplay.getRootHomeTask(); + mRootHomeTask = mDefaultDisplay.getDefaultTaskDisplayArea().getRootHomeTask(); assertNotNull(mRootHomeTask); } 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 6810f6442c66..881561f5750b 100644 --- a/services/tests/wmtests/src/com/android/server/wm/RecentsAnimationTest.java +++ b/services/tests/wmtests/src/com/android/server/wm/RecentsAnimationTest.java @@ -88,7 +88,7 @@ public class RecentsAnimationTest extends ActivityTestsBase { @Test public void testRecentsActivityVisiblility() { - TaskDisplayArea taskDisplayArea = mRootWindowContainer.getDefaultDisplay().mTaskContainers; + TaskDisplayArea taskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea(); ActivityStack recentsStack = taskDisplayArea.createStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_RECENTS, true /* onTop */); ActivityRecord recentActivity = new ActivityBuilder(mService) @@ -116,8 +116,7 @@ public class RecentsAnimationTest extends ActivityTestsBase { @Test public void testPreloadRecentsActivity() { - TaskDisplayArea defaultTaskDisplayArea = mRootWindowContainer.getDefaultDisplay() - .mTaskContainers; + TaskDisplayArea defaultTaskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea(); final ActivityStack homeStack = defaultTaskDisplayArea.getStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_HOME); defaultTaskDisplayArea.positionStackAtTop(homeStack, false /* includingParents */); @@ -178,8 +177,7 @@ public class RecentsAnimationTest extends ActivityTestsBase { @Test public void testRestartRecentsActivity() throws Exception { // Have a recents activity that is not attached to its process (ActivityRecord.app = null). - TaskDisplayArea defaultTaskDisplayArea = mRootWindowContainer.getDefaultDisplay() - .mTaskContainers; + TaskDisplayArea defaultTaskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea(); ActivityStack recentsStack = defaultTaskDisplayArea.createStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_RECENTS, true /* onTop */); ActivityRecord recentActivity = new ActivityBuilder(mService).setComponent( @@ -208,7 +206,7 @@ public class RecentsAnimationTest extends ActivityTestsBase { @Test public void testSetLaunchTaskBehindOfTargetActivity() { - TaskDisplayArea taskDisplayArea = mRootWindowContainer.getDefaultDisplay().mTaskContainers; + TaskDisplayArea taskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea(); ActivityStack homeStack = taskDisplayArea.getRootHomeTask(); // Assume the home activity support recents. ActivityRecord targetActivity = homeStack.getTopNonFinishingActivity(); @@ -253,7 +251,7 @@ public class RecentsAnimationTest extends ActivityTestsBase { @Test public void testCancelAnimationOnVisibleStackOrderChange() { - TaskDisplayArea taskDisplayArea = mRootWindowContainer.getDefaultDisplay().mTaskContainers; + TaskDisplayArea taskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea(); ActivityStack fullscreenStack = taskDisplayArea.createStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */); new ActivityBuilder(mService) @@ -298,7 +296,7 @@ public class RecentsAnimationTest extends ActivityTestsBase { @Test public void testKeepAnimationOnHiddenStackOrderChange() { - TaskDisplayArea taskDisplayArea = mRootWindowContainer.getDefaultDisplay().mTaskContainers; + TaskDisplayArea taskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea(); ActivityStack fullscreenStack = taskDisplayArea.createStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */); new ActivityBuilder(mService) @@ -334,7 +332,8 @@ public class RecentsAnimationTest extends ActivityTestsBase { @Test public void testMultipleUserHomeActivity_findUserHomeTask() { - TaskDisplayArea taskDisplayArea = mRootWindowContainer.getDefaultDisplay().mTaskContainers; + TaskDisplayArea taskDisplayArea = mRootWindowContainer.getDefaultDisplay() + .getDefaultTaskDisplayArea(); ActivityStack homeStack = taskDisplayArea.getStack(WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_HOME); ActivityRecord otherUserHomeActivity = new ActivityBuilder(mService) 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 836310496d0b..48d4e705ff4b 100644 --- a/services/tests/wmtests/src/com/android/server/wm/RootActivityContainerTests.java +++ b/services/tests/wmtests/src/com/android/server/wm/RootActivityContainerTests.java @@ -89,7 +89,7 @@ public class RootActivityContainerTests extends ActivityTestsBase { @Before public void setUp() throws Exception { - mFullscreenStack = mRootWindowContainer.getDefaultDisplay().createStack( + mFullscreenStack = mRootWindowContainer.getDefaultTaskDisplayArea().createStack( WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */); doNothing().when(mService).updateSleepIfNeededLocked(); } @@ -129,8 +129,8 @@ public class RootActivityContainerTests extends ActivityTestsBase { mRootWindowContainer.moveActivityToPinnedStack(firstActivity, sourceBounds, 0f /*aspectRatio*/, "initialMove"); - final DisplayContent display = mFullscreenStack.getDisplay(); - ActivityStack pinnedStack = display.getRootPinnedTask(); + final TaskDisplayArea taskDisplayArea = mFullscreenStack.getDisplayArea(); + ActivityStack pinnedStack = taskDisplayArea.getRootPinnedTask(); // Ensure a task has moved over. ensureStackPlacement(pinnedStack, firstActivity); ensureStackPlacement(mFullscreenStack, secondActivity); @@ -140,8 +140,9 @@ public class RootActivityContainerTests extends ActivityTestsBase { 0f /*aspectRatio*/, "secondMove"); // Need to get stacks again as a new instance might have been created. - pinnedStack = display.getRootPinnedTask(); - mFullscreenStack = display.getStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD); + pinnedStack = taskDisplayArea.getRootPinnedTask(); + mFullscreenStack = taskDisplayArea.getStack(WINDOWING_MODE_FULLSCREEN, + ACTIVITY_TYPE_STANDARD); // Ensure stacks have swapped tasks. ensureStackPlacement(pinnedStack, secondActivity); ensureStackPlacement(mFullscreenStack, firstActivity); @@ -215,6 +216,8 @@ public class RootActivityContainerTests extends ActivityTestsBase { doReturn(isFocusedStack).when(stack).isFocusedStackOnDisplay(); doReturn(isFocusedStack ? stack : null).when(display).getFocusedStack(); + TaskDisplayArea defaultTaskDisplayArea = display.getDefaultTaskDisplayArea(); + doReturn(isFocusedStack ? stack : null).when(defaultTaskDisplayArea).getFocusedStack(); mRootWindowContainer.applySleepTokens(true); verify(stack, times(expectWakeFromSleep ? 1 : 0)).awakeFromSleepingLocked(); verify(stack, times(expectResumeTopActivity ? 1 : 0)).resumeTopActivityUncheckedLocked( @@ -226,26 +229,29 @@ public class RootActivityContainerTests extends ActivityTestsBase { */ @Test public void testRemovingStackOnAppCrash() { - final DisplayContent defaultDisplay = mRootWindowContainer.getDefaultDisplay(); - final int originalStackCount = defaultDisplay.getStackCount(); - final ActivityStack stack = mRootWindowContainer.getDefaultDisplay().createStack( + final TaskDisplayArea defaultTaskDisplayArea = mRootWindowContainer + .getDefaultTaskDisplayArea(); + final int originalStackCount = defaultTaskDisplayArea.getStackCount(); + final ActivityStack stack = defaultTaskDisplayArea.createStack( WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, false /* onTop */); final ActivityRecord firstActivity = new ActivityBuilder(mService).setCreateTask(true) .setStack(stack).build(); - assertEquals(originalStackCount + 1, defaultDisplay.getStackCount()); + assertEquals(originalStackCount + 1, defaultTaskDisplayArea.getStackCount()); // 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, defaultDisplay.getStackCount()); + assertEquals(originalStackCount, defaultTaskDisplayArea.getStackCount()); } @Test public void testFocusability() { - final ActivityStack stack = mRootWindowContainer.getDefaultDisplay().createStack( + final TaskDisplayArea defaultTaskDisplayArea = mRootWindowContainer + .getDefaultTaskDisplayArea(); + final ActivityStack stack = defaultTaskDisplayArea.createStack( WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, ACTIVITY_TYPE_STANDARD, true /* onTop */); final ActivityRecord activity = new ActivityBuilder(mService).setCreateTask(true) .setStack(stack).build(); @@ -259,7 +265,7 @@ public class RootActivityContainerTests extends ActivityTestsBase { assertFalse(stack.isTopActivityFocusable()); assertFalse(activity.isFocusable()); - final ActivityStack pinnedStack = mRootWindowContainer.getDefaultDisplay().createStack( + final ActivityStack pinnedStack = defaultTaskDisplayArea.createStack( WINDOWING_MODE_PINNED, ACTIVITY_TYPE_STANDARD, true /* onTop */); final ActivityRecord pinnedActivity = new ActivityBuilder(mService).setCreateTask(true) .setStack(pinnedStack).build(); @@ -288,7 +294,7 @@ public class RootActivityContainerTests extends ActivityTestsBase { @Test public void testSplitScreenPrimaryChosenWhenTopActivityLaunchedToSecondary() { // Create primary split-screen stack with a task and an activity. - final ActivityStack primaryStack = mRootWindowContainer.getDefaultDisplay() + final ActivityStack primaryStack = mRootWindowContainer.getDefaultTaskDisplayArea() .createStack(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, ACTIVITY_TYPE_STANDARD, true /* onTop */); final Task task = new TaskBuilder(mSupervisor).setStack(primaryStack).build(); @@ -311,7 +317,6 @@ public class RootActivityContainerTests extends ActivityTestsBase { @Test public void testFindTaskToMoveToFrontWhenRecentsOnTop() { // Create stack/task on default display. - final DisplayContent display = mRootWindowContainer.getDefaultDisplay(); final ActivityStack targetStack = new StackBuilder(mRootWindowContainer) .setOnTop(false) .build(); @@ -325,7 +330,7 @@ public class RootActivityContainerTests extends ActivityTestsBase { mSupervisor.findTaskToMoveToFront(targetTask, 0, ActivityOptions.makeBasic(), reason, false); - final TaskDisplayArea taskDisplayArea = display.mTaskContainers; + final TaskDisplayArea taskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea(); verify(taskDisplayArea).moveHomeStackToFront(contains(reason)); } @@ -336,8 +341,8 @@ public class RootActivityContainerTests extends ActivityTestsBase { @Test public void testFindTaskToMoveToFrontWhenRecentsOnOtherDisplay() { // Create stack/task on default display. - final DisplayContent display = mRootWindowContainer.getDefaultDisplay(); - final ActivityStack targetStack = display.createStack(WINDOWING_MODE_FULLSCREEN, + final TaskDisplayArea taskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea(); + final ActivityStack targetStack = taskDisplayArea.createStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, false /* onTop */); final Task targetTask = new TaskBuilder(mSupervisor).setStack(targetStack).build(); @@ -353,7 +358,6 @@ public class RootActivityContainerTests extends ActivityTestsBase { mSupervisor.findTaskToMoveToFront(targetTask, 0, ActivityOptions.makeBasic(), reason, false); - final TaskDisplayArea taskDisplayArea = display.mTaskContainers; verify(taskDisplayArea, never()).moveHomeStackToFront(contains(reason)); } @@ -364,12 +368,12 @@ public class RootActivityContainerTests extends ActivityTestsBase { @Test public void testResumeActivityWhenNonTopmostStackIsTopFocused() { // Create a stack at bottom. - final DisplayContent display = mRootWindowContainer.getDefaultDisplay(); - final ActivityStack targetStack = spy(display.createStack(WINDOWING_MODE_FULLSCREEN, + final TaskDisplayArea taskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea(); + final ActivityStack targetStack = spy(taskDisplayArea.createStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, false /* onTop */)); final Task task = new TaskBuilder(mSupervisor).setStack(targetStack).build(); final ActivityRecord activity = new ActivityBuilder(mService).setTask(task).build(); - display.mTaskContainers.positionStackAtBottom(targetStack); + taskDisplayArea.positionStackAtBottom(targetStack); // Assume the stack is not at the topmost position (e.g. behind always-on-top stacks) but it // is the current top focused stack. @@ -392,10 +396,9 @@ public class RootActivityContainerTests extends ActivityTestsBase { @Test public void testResumeFocusedStacksStartsHomeActivity_NoActivities() { mFullscreenStack.removeIfPossible(); - mService.mRootWindowContainer.getDisplayContent(DEFAULT_DISPLAY).getRootHomeTask() - .removeIfPossible(); - mService.mRootWindowContainer.getDisplayContent(DEFAULT_DISPLAY) - .createStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_HOME, ON_TOP); + final TaskDisplayArea taskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea(); + taskDisplayArea.getRootHomeTask().removeIfPossible(); + taskDisplayArea.createStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_HOME, ON_TOP); doReturn(true).when(mRootWindowContainer).resumeHomeActivity(any(), any(), anyInt()); @@ -415,16 +418,15 @@ public class RootActivityContainerTests extends ActivityTestsBase { @Test public void testResumeFocusedStacksStartsHomeActivity_ActivityOnSecondaryScreen() { mFullscreenStack.removeIfPossible(); - mService.mRootWindowContainer.getDisplayContent(DEFAULT_DISPLAY).getRootHomeTask() - .removeIfPossible(); - mService.mRootWindowContainer.getDisplayContent(DEFAULT_DISPLAY) - .createStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_HOME, ON_TOP); + final TaskDisplayArea taskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea(); + taskDisplayArea.getRootHomeTask().removeIfPossible(); + taskDisplayArea.createStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_HOME, ON_TOP); // Create an activity on secondary display. final TestDisplayContent secondDisplay = addNewDisplayContentAt( DisplayContent.POSITION_TOP); - final ActivityStack stack = secondDisplay.createStack(WINDOWING_MODE_FULLSCREEN, - ACTIVITY_TYPE_STANDARD, true /* onTop */); + final ActivityStack stack = secondDisplay.getDefaultTaskDisplayArea() + .createStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */); final Task task = new TaskBuilder(mSupervisor).setStack(stack).build(); new ActivityBuilder(mService).setTask(task).build(); @@ -446,8 +448,8 @@ public class RootActivityContainerTests extends ActivityTestsBase { @Test public void testResumeActivityLingeringTransition() { // Create a stack at top. - final DisplayContent display = mRootWindowContainer.getDefaultDisplay(); - final ActivityStack targetStack = spy(display.createStack(WINDOWING_MODE_FULLSCREEN, + final TaskDisplayArea taskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea(); + final ActivityStack targetStack = spy(taskDisplayArea.createStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, false /* onTop */)); final Task task = new TaskBuilder(mSupervisor).setStack(targetStack).build(); final ActivityRecord activity = new ActivityBuilder(mService).setTask(task).build(); @@ -466,13 +468,13 @@ public class RootActivityContainerTests extends ActivityTestsBase { @Test public void testResumeActivityLingeringTransition_notExecuted() { // Create a stack at bottom. - final DisplayContent display = mRootWindowContainer.getDefaultDisplay(); - final ActivityStack targetStack = spy(display.createStack(WINDOWING_MODE_FULLSCREEN, + final TaskDisplayArea taskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea(); + final ActivityStack targetStack = spy(taskDisplayArea.createStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, false /* onTop */)); final Task task = new TaskBuilder(mSupervisor).setStack(targetStack).build(); final ActivityRecord activity = new ActivityBuilder(mService).setTask(task).build(); activity.setState(ActivityState.RESUMED, "test"); - display.mTaskContainers.positionStackAtBottom(targetStack); + taskDisplayArea.positionStackAtBottom(targetStack); // Assume the stack is at the topmost position assertFalse(targetStack.isTopStackInDisplayArea()); @@ -809,20 +811,20 @@ public class RootActivityContainerTests extends ActivityTestsBase { public void testSwitchUser_missingHomeRootTask() { doReturn(mFullscreenStack).when(mRootWindowContainer).getTopDisplayFocusedStack(); - DisplayContent defaultDisplay = mRootWindowContainer.getDefaultDisplay(); - ActivityStack homeStack = defaultDisplay.getRootHomeTask(); + final TaskDisplayArea taskDisplayArea = mRootWindowContainer.getDefaultTaskDisplayArea(); + ActivityStack homeStack = taskDisplayArea.getRootHomeTask(); if (homeStack != null) { homeStack.removeImmediately(); } - assertNull(defaultDisplay.getRootHomeTask()); + assertNull(taskDisplayArea.getRootHomeTask()); int currentUser = mRootWindowContainer.mCurrentUser; int otherUser = currentUser + 1; mRootWindowContainer.switchUser(otherUser, null); - assertNotNull(defaultDisplay.getRootHomeTask()); - assertEquals(defaultDisplay.getTopStack(), defaultDisplay.getRootHomeTask()); + assertNotNull(taskDisplayArea.getRootHomeTask()); + assertEquals(taskDisplayArea.getTopStack(), taskDisplayArea.getRootHomeTask()); } /** 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 d6a67abc9e76..3d3a0f148db5 100644 --- a/services/tests/wmtests/src/com/android/server/wm/RunningTasksTest.java +++ b/services/tests/wmtests/src/com/android/server/wm/RunningTasksTest.java @@ -72,7 +72,8 @@ public class RunningTasksTest extends ActivityTestsBase { final int numTasks = 10; int activeTime = 0; for (int i = 0; i < numTasks; i++) { - createTask(display.getStackAt(i % numStacks), ".Task" + i, i, activeTime++, null); + createTask(display.getDefaultTaskDisplayArea().getStackAt(i % numStacks), + ".Task" + i, i, activeTime++, null); } // Ensure that the latest tasks were returned in order of decreasing last active time, diff --git a/services/tests/wmtests/src/com/android/server/wm/SizeCompatTests.java b/services/tests/wmtests/src/com/android/server/wm/SizeCompatTests.java index 893a14541c48..673469474709 100644 --- a/services/tests/wmtests/src/com/android/server/wm/SizeCompatTests.java +++ b/services/tests/wmtests/src/com/android/server/wm/SizeCompatTests.java @@ -189,7 +189,7 @@ public class SizeCompatTests extends ActivityTestsBase { final int originalDpi = mActivity.getConfiguration().densityDpi; // Move the non-resizable activity to the new display. - mStack.reparent(newDisplay.mDisplayContent, true /* onTop */); + mStack.reparent(newDisplay.getDefaultTaskDisplayArea(), true /* onTop */); assertEquals(originalBounds.width(), mActivity.getBounds().width()); assertEquals(originalBounds.height(), mActivity.getBounds().height()); @@ -257,7 +257,7 @@ public class SizeCompatTests extends ActivityTestsBase { .setCanRotate(false).setNotch(notchHeight).build(); // Move the non-resizable activity to the new display. - mStack.reparent(newDisplay, true /* onTop */); + mStack.reparent(newDisplay.getDefaultTaskDisplayArea(), true /* onTop */); // The configuration bounds should keep the same. assertEquals(origWidth, configBounds.width()); assertEquals(origHeight, configBounds.height()); 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 af76e7fc0b76..af3ec38631ae 100644 --- a/services/tests/wmtests/src/com/android/server/wm/SystemServicesTestRule.java +++ b/services/tests/wmtests/src/com/android/server/wm/SystemServicesTestRule.java @@ -316,7 +316,7 @@ public class SystemServicesTestRule implements TestRule { // that the default display is in fullscreen mode. display.setDisplayWindowingMode(WINDOWING_MODE_FULLSCREEN); spyOn(display); - final TaskDisplayArea taskDisplayArea = display.mTaskContainers; + final TaskDisplayArea taskDisplayArea = display.getDefaultTaskDisplayArea(); spyOn(taskDisplayArea); final ActivityStack homeStack = taskDisplayArea.getStack( WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_HOME); 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 a3446d16d9f3..1a38ff283477 100644 --- a/services/tests/wmtests/src/com/android/server/wm/TaskLaunchParamsModifierTests.java +++ b/services/tests/wmtests/src/com/android/server/wm/TaskLaunchParamsModifierTests.java @@ -1312,14 +1312,14 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase { } private ActivityRecord createSourceActivity(TestDisplayContent display) { - final ActivityStack stack = display.createStack(display.getWindowingMode(), - ACTIVITY_TYPE_STANDARD, true); + final ActivityStack stack = display.getDefaultTaskDisplayArea() + .createStack(display.getWindowingMode(), ACTIVITY_TYPE_STANDARD, true); return new ActivityBuilder(mService).setStack(stack).setCreateTask(true).build(); } private void addFreeformTaskTo(TestDisplayContent display, Rect bounds) { - final ActivityStack stack = display.createStack(display.getWindowingMode(), - ACTIVITY_TYPE_STANDARD, true); + final ActivityStack stack = display.getDefaultTaskDisplayArea() + .createStack(display.getWindowingMode(), ACTIVITY_TYPE_STANDARD, true); stack.setWindowingMode(WINDOWING_MODE_FREEFORM); final Task task = new TaskBuilder(mSupervisor).setStack(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 f76809b06510..50584c61cf92 100644 --- a/services/tests/wmtests/src/com/android/server/wm/TaskRecordTests.java +++ b/services/tests/wmtests/src/com/android/server/wm/TaskRecordTests.java @@ -203,9 +203,9 @@ public class TaskRecordTests extends ActivityTestsBase { @Test public void testFitWithinBounds() { final Rect parentBounds = new Rect(10, 10, 200, 200); - DisplayContent display = mService.mRootWindowContainer.getDefaultDisplay(); - ActivityStack stack = display.createStack(WINDOWING_MODE_FREEFORM, ACTIVITY_TYPE_STANDARD, - true /* onTop */); + TaskDisplayArea taskDisplayArea = mService.mRootWindowContainer.getDefaultTaskDisplayArea(); + ActivityStack stack = taskDisplayArea.createStack(WINDOWING_MODE_FREEFORM, + ACTIVITY_TYPE_STANDARD, true /* onTop */); Task task = new TaskBuilder(mSupervisor).setStack(stack).build(); final Configuration parentConfig = stack.getConfiguration(); parentConfig.windowConfiguration.setBounds(parentBounds); @@ -438,9 +438,9 @@ public class TaskRecordTests extends ActivityTestsBase { @Test public void testInsetDisregardedWhenFreeformOverlapsNavBar() { - DisplayContent display = mService.mRootWindowContainer.getDefaultDisplay(); - ActivityStack stack = display.createStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, - true /* onTop */); + TaskDisplayArea taskDisplayArea = mService.mRootWindowContainer.getDefaultTaskDisplayArea(); + ActivityStack stack = taskDisplayArea.createStack(WINDOWING_MODE_FULLSCREEN, + ACTIVITY_TYPE_STANDARD, true /* onTop */); DisplayInfo displayInfo = new DisplayInfo(); mService.mContext.getDisplay().getDisplayInfo(displayInfo); final int displayHeight = displayInfo.logicalHeight; @@ -959,8 +959,8 @@ public class TaskRecordTests extends ActivityTestsBase { private void testStackBoundsConfiguration(int windowingMode, Rect parentBounds, Rect bounds, Rect expectedConfigBounds) { - DisplayContent display = mService.mRootWindowContainer.getDefaultDisplay(); - ActivityStack stack = display.createStack(windowingMode, ACTIVITY_TYPE_STANDARD, + TaskDisplayArea taskDisplayArea = mService.mRootWindowContainer.getDefaultTaskDisplayArea(); + ActivityStack stack = taskDisplayArea.createStack(windowingMode, ACTIVITY_TYPE_STANDARD, true /* onTop */); Task task = new TaskBuilder(mSupervisor).setStack(stack).build(); diff --git a/services/tests/wmtests/src/com/android/server/wm/TaskStackTests.java b/services/tests/wmtests/src/com/android/server/wm/TaskStackTests.java index 6387a3b7c474..d48e82723295 100644 --- a/services/tests/wmtests/src/com/android/server/wm/TaskStackTests.java +++ b/services/tests/wmtests/src/com/android/server/wm/TaskStackTests.java @@ -171,7 +171,7 @@ public class TaskStackTests extends WindowTestsBase { // Reparent clearInvocations(task1); // reset the number of onDisplayChanged for task. - stack1.reparent(dc, true /* onTop */); + stack1.reparent(dc.getDefaultTaskDisplayArea(), true /* onTop */); assertEquals(dc, stack1.getDisplayContent()); final int stack1PositionInParent = stack1.getParent().mChildren.indexOf(stack1); final int stack2PositionInParent = stack1.getParent().mChildren.indexOf(stack2); diff --git a/services/tests/wmtests/src/com/android/server/wm/WallpaperControllerTests.java b/services/tests/wmtests/src/com/android/server/wm/WallpaperControllerTests.java index 900f014a0218..a4f1487dde1e 100644 --- a/services/tests/wmtests/src/com/android/server/wm/WallpaperControllerTests.java +++ b/services/tests/wmtests/src/com/android/server/wm/WallpaperControllerTests.java @@ -254,7 +254,7 @@ public class WallpaperControllerTests extends WindowTestsBase { private WindowState createWallpaperTargetWindow(DisplayContent dc) { final ActivityRecord homeActivity = new ActivityTestsBase.ActivityBuilder(mWm.mAtmService) - .setStack(dc.getRootHomeTask()) + .setStack(dc.getDefaultTaskDisplayArea().getRootHomeTask()) .setCreateTask(true) .build(); homeActivity.setVisibility(true); 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 27ea37dfeb19..118c2e4db208 100644 --- a/services/tests/wmtests/src/com/android/server/wm/WindowContainerTests.java +++ b/services/tests/wmtests/src/com/android/server/wm/WindowContainerTests.java @@ -780,8 +780,8 @@ public class WindowContainerTests extends WindowTestsBase { WindowTestUtils.createActivityRecordInTask(mDisplayContent, task); final DisplayContent newDc = createNewDisplay(); - mDisplayContent.removeStack(stack); - newDc.mTaskContainers.addChild(stack, POSITION_TOP); + stack.getDisplayArea().removeStack(stack); + newDc.getDefaultTaskDisplayArea().addChild(stack, POSITION_TOP); verify(stack).onDisplayChanged(newDc); verify(task).onDisplayChanged(newDc); |