4/n Add fallback to default task display area
... for the cases when a particular task display area target is not
specified, and/or the logic applies only to the default/fallback
task area on the display.
Bug: 152116619
Test: WM CTS and unit tests
Change-Id: I209629baada05b0615ea2874f39a2b30a95b7565
diff --git a/services/core/java/com/android/server/wm/ActivityStack.java b/services/core/java/com/android/server/wm/ActivityStack.java
index 10b335e..a446720 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 @@
}
}
- 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 2c7ce91..8af8624 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 @@
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 @@
}
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 @@
// 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 7803c73..0b19687 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 @@
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 @@
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 682a142..e8becfa 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 @@
* - 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 55b7be779..85517a4 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 @@
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 @@
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 @@
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 @@
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 @@
*/
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 @@
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 @@
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 @@
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 @@
// 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 @@
// 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 @@
// 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 @@
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 @@
}
/**
- * 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 221258e..264da9f 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 @@
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 @@
}
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 af89a05..bef80f0 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 @@
// 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 007af24..e4e5716 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 @@
}
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 a936e74..57a54d0 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 @@
// 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 66dbfd5..02a2741 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 @@
}
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 08b0abf..a031fe8 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 @@
* 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 @@
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 @@
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 @@
// 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 @@
}
// 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 @@
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 @@
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 @@
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 @@
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 @@
mWindowManager.getRecentsAnimationController(), reorderMode);
// Unregister for stack order changes
- mDefaultDisplay.unregisterStackOrderChangedListener(this);
+ mDefaultTaskDisplayArea.unregisterStackOrderChangedListener(this);
final RecentsAnimationController controller =
mWindowManager.getRecentsAnimationController();
@@ -308,7 +308,7 @@
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 @@
@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 @@
* @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 a30b70d..84229f0 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 @@
// 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 @@
}
// 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 770c088..32de699 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 @@
}
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 @@
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 @@
}
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 2764b12..2eeda4d 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 @@
}
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 @@
}
/**
+ * 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
// 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 @@
continue;
}
- display.mTaskContainers.findTaskLocked(r, false /* isPreferredDisplay */,
+ display.getDefaultTaskDisplayArea().findTaskLocked(r, false /* isPreferredDisplay */,
mTmpFindTaskResult);
if (mTmpFindTaskResult.mIdealMatch) {
return mTmpFindTaskResult.mRecord;
@@ -2788,8 +2794,10 @@
}
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 @@
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 @@
// 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 @@
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 @@
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 @@
// 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 @@
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 77ef011..13e4d8b 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 @@
* 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 @@
// 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 @@
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 @@
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 @@
@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 @@
mPreferredTopFocusableStack = null;
}
mDisplayContent.releaseSelfIfNeeded();
- mDisplayContent.onStackOrderChanged(stack);
+ onStackOrderChanged(stack);
}
void positionStackAt(int position, ActivityStack child, boolean includingParents) {
@@ -716,7 +722,7 @@
}
}
- mDisplayContent.onStackOrderChanged(stack);
+ onStackOrderChanged(stack);
}
ActivityStack getStack(int rootTaskId) {
@@ -765,11 +771,11 @@
} 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 @@
// 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 @@
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 @@
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 b641e4c..9ffd8d2 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 @@
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 e43f4b4..b9b6c08 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 @@
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 dfaa0ec..687af64 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 @@
@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 a332b69..3e2e9be 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 @@
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 b87d181..8e7585a 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 @@
// 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 3c2b6ec..7457a1d 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 @@
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 05604b2..1debd8c 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 @@
@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 @@
@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 @@
}
/**
- * 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 @@
assertTrue(stack1.isFocusedStackOnDisplay());
// Stack2 should be focused after removing stack1.
- display.removeStack(stack1);
+ stack1.getDisplayArea().removeStack(stack1);
assertTrue(stack2.isFocusedStackOnDisplay());
}
@@ -156,7 +157,7 @@
}
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 @@
*/
@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 @@
}
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 @@
// 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 747ae94..b6b20c9 100644
--- a/services/tests/wmtests/src/com/android/server/wm/ActivityRecordTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/ActivityRecordTests.java
@@ -1379,8 +1379,8 @@
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 e8c0362..22d7fcb 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 @@
@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 af5afff..3d15401 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 @@
@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 @@
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 @@
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 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 @@
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 @@
@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 @@
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 @@
@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 @@
@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 @@
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 @@
@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 @@
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 @@
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 @@
@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 @@
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 @@
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 @@
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 @@
@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 @@
}
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 @@
@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 @@
@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 @@
// 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 @@
// 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 @@
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 @@
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 @@
@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 @@
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 @@
@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 @@
@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 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 @@
@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 @@
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 @@
@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 @@
}
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 76a761c..27782f5 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 @@
.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 1d952bf..1cca207 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 @@
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 @@
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 @@
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 @@
// 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 @@
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 9240b22..67d4769 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 @@
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 @@
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 @@
StackBuilder(RootWindowContainer root) {
mRootWindowContainer = root;
mDisplay = mRootWindowContainer.getDefaultDisplay();
+ mTaskDisplayArea = mDisplay.getDefaultTaskDisplayArea();
}
StackBuilder setWindowingMode(int windowingMode) {
@@ -436,8 +438,20 @@
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 @@
}
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 4cb50c7..9b7ffd6 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 @@
// 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 8b91c7e..8c8fd05 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 @@
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 38b3d76..a901d1e 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 @@
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 @@
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 @@
@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 @@
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 @@
@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 @@
@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 cf7411e..9b2a2db 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 @@
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 ae467c0..6a71a7d 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 @@
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 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 @@
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 071386f..d9c3ace 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_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 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 da07bac..6d2b7b1 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 @@
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 6810f64..881561f 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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 83631049..48d4e70 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 @@
@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 @@
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 @@
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 @@
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 @@
*/
@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 @@
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 @@
@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 @@
@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 @@
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 @@
@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 @@
mSupervisor.findTaskToMoveToFront(targetTask, 0, ActivityOptions.makeBasic(), reason,
false);
- final TaskDisplayArea taskDisplayArea = display.mTaskContainers;
verify(taskDisplayArea, never()).moveHomeStackToFront(contains(reason));
}
@@ -364,12 +368,12 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 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 d6a67ab..3d3a0f1 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 @@
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 893a145..6734694 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 @@
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 @@
.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 af76e7f..af3ec38 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 @@
// 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 a3446d1..1a38ff2 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 @@
}
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 f76809b..50584c6 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 @@
@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 @@
@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 @@
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 6387a3b..d48e827 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 @@
// 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 900f014..a4f1487 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 @@
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 27ea37d..118c2e4 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 @@
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);