Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Allow TaskDisplayArea to have TaskDisplayArea children (3/n)"

Browse Source
This commit is contained in:
Chris Li
2020-12-17 21:35:12 +00:00
committed by Android (Google) Code Review
parent 09496f9527 4a85741bd0
commit 56cf2dd5b4
11 changed files with 584 additions and 348 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
data/etc/services.core.protolog.json
View File

@@ -901,6 +901,12 @@
"group": "WM_DEBUG_ORIENTATION",
"at": "com\/android\/server\/wm\/WindowManagerService.java"
},
"-1069336896": {
"message": "onRootTaskOrderChanged(): rootTask=%s",
"level": "DEBUG",
"group": "WM_DEBUG_RECENTS_ANIMATIONS",
"at": "com\/android\/server\/wm\/RecentsAnimation.java"
},
"-1066383762": {
"message": "Sleep still waiting to pause %s",
"level": "VERBOSE",
@@ -1303,6 +1309,12 @@
"group": "WM_DEBUG_CONFIGURATION",
"at": "com\/android\/server\/am\/ActivityManagerService.java"
},
"-592371899": {
"message": "Skipping rootTask: (mismatch activity\/rootTask) %s",
"level": "DEBUG",
"group": "WM_DEBUG_TASKS",
"at": "com\/android\/server\/wm\/TaskDisplayArea.java"
},
"-583031528": {
"message": "%s",
"level": "INFO",
@@ -2119,12 +2131,6 @@
"group": "WM_DEBUG_APP_TRANSITIONS",
"at": "com\/android\/server\/wm\/AppTransition.java"
},
"349443311": {
"message": "pauseBackStacks: task=%s mResumedActivity=%s",
"level": "DEBUG",
"group": "WM_DEBUG_STATES",
"at": "com\/android\/server\/wm\/TaskDisplayArea.java"
},
"355720268": {
"message": "stopFreezingDisplayLocked: Unfreezing now",
"level": "DEBUG",
@@ -2161,6 +2167,12 @@
"group": "WM_DEBUG_BOOT",
"at": "com\/android\/server\/wm\/WindowManagerService.java"
},
"391189028": {
"message": "pauseBackTasks: task=%s mResumedActivity=%s",
"level": "DEBUG",
"group": "WM_DEBUG_STATES",
"at": "com\/android\/server\/wm\/TaskDisplayArea.java"
},
"397105698": {
"message": "grantEmbeddedWindowFocus remove request for win=%s dropped since no candidate was found",
"level": "VERBOSE",
@@ -2245,12 +2257,6 @@
"group": "WM_DEBUG_WINDOW_ORGANIZER",
"at": "com\/android\/server\/wm\/DisplayAreaOrganizerController.java"
},
"490877640": {
"message": "onStackOrderChanged(): stack=%s",
"level": "DEBUG",
"group": "WM_DEBUG_RECENTS_ANIMATIONS",
"at": "com\/android\/server\/wm\/RecentsAnimation.java"
},
"495032901": {
"message": "Expected target stack=%s to restored behind stack=%s but it is behind stack=%s",
"level": "WARN",
@@ -2575,12 +2581,6 @@
"group": "WM_DEBUG_REMOTE_ANIMATIONS",
"at": "com\/android\/server\/wm\/RemoteAnimationController.java"
},
"875196661": {
"message": "Skipping stack: (mismatch activity\/stack) %s",
"level": "DEBUG",
"group": "WM_DEBUG_TASKS",
"at": "com\/android\/server\/wm\/TaskDisplayArea.java"
},
"883475718": {
"message": "Report configuration: %s %s %s",
"level": "VERBOSE",

23
services/core/java/com/android/server/wm/DisplayContent.java
View File

@@ -2300,10 +2300,9 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
return count[0];
}
@VisibleForTesting
@Nullable
Task getTopRootTask() {
return getItemFromTaskDisplayAreas(TaskDisplayArea::getTopRootTask);
return getRootTask(t -> true);
}
/**
@@ -5479,12 +5478,12 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
return;
}
// Check if all task display areas have only the empty home stacks left.
boolean hasNonEmptyHomeStack = forAllRootTasks(stack ->
!stack.isActivityTypeHome() || stack.hasChild());
if (!hasNonEmptyHomeStack && getRootTaskCount() > 0) {
// Release this display if only empty home stack(s) are left. This display will be
// released along with the stack(s) removal.
// Check if all task display areas have only the empty home root tasks left.
boolean hasNonEmptyHomeRootTask = forAllRootTasks(rootTask ->
!rootTask.isActivityTypeHome() || rootTask.hasChild());
if (!hasNonEmptyHomeRootTask && getRootTaskCount() > 0) {
// Release this display if only empty home root task(s) are left. This display will be
// released along with the root task(s) removal.
forAllRootTasks(Task::removeIfPossible);
} else if (getTopRootTask() == null) {
removeIfPossible();
@@ -5525,12 +5524,14 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
return;
}
mInEnsureActivitiesVisible = true;
mAtmService.mTaskSupervisor.beginActivityVisibilityUpdate();
try {
forAllTaskDisplayAreas(taskDisplayArea -> {
taskDisplayArea.ensureActivitiesVisible(starting, configChanges,
preserveWindows, notifyClients, userLeaving);
forAllRootTasks(rootTask -> {
rootTask.ensureActivitiesVisible(starting, configChanges, preserveWindows,
notifyClients, userLeaving);
});
} finally {
mAtmService.mTaskSupervisor.endActivityVisibilityUpdate();
mInEnsureActivitiesVisible = false;
}
}

7
services/core/java/com/android/server/wm/RecentsAnimation.java
View File

@@ -413,9 +413,10 @@ class RecentsAnimation implements RecentsAnimationCallbacks, OnRootTaskOrderChan
@Override
public void onRootTaskOrderChanged(Task rootTask) {
ProtoLog.d(WM_DEBUG_RECENTS_ANIMATIONS, "onStackOrderChanged(): stack=%s", rootTask);
if (mDefaultTaskDisplayArea.getIndexOf(rootTask) == -1 || !rootTask.shouldBeVisible(null)) {
// The stack is not visible, so ignore this change
ProtoLog.d(WM_DEBUG_RECENTS_ANIMATIONS, "onRootTaskOrderChanged(): rootTask=%s", rootTask);
if (mDefaultTaskDisplayArea.getRootTask(t -> t == rootTask) == null
|| !rootTask.shouldBeVisible(null)) {
// The root task is not visible, so ignore this change
return;
}
final RecentsAnimationController controller =

140
services/core/java/com/android/server/wm/RootWindowContainer.java
View File

@@ -1828,19 +1828,19 @@ class RootWindowContainer extends WindowContainer<DisplayContent>
}
/**
* @return a list of activities which are the top ones in each visible stack. The first
* @return a list of activities which are the top ones in each visible root task. The first
* entry will be the focused activity.
*/
List<IBinder> getTopVisibleActivities() {
final ArrayList<IBinder> topActivityTokens = new ArrayList<>();
final Task topFocusedStack = getTopDisplayFocusedRootTask();
final Task topFocusedRootTask = getTopDisplayFocusedRootTask();
// Traverse all displays.
forAllRootTasks(stack -> {
// Get top activity from a visible stack and add it to the list.
if (stack.shouldBeVisible(null /* starting */)) {
final ActivityRecord top = stack.getTopNonFinishingActivity();
forAllRootTasks(rootTask -> {
// Get top activity from a visible root task and add it to the list.
if (rootTask.shouldBeVisible(null /* starting */)) {
final ActivityRecord top = rootTask.getTopNonFinishingActivity();
if (top != null) {
if (stack == topFocusedStack) {
if (rootTask == topFocusedRootTask) {
topActivityTokens.add(0, top.appToken);
} else {
topActivityTokens.add(top.appToken);
@@ -1854,9 +1854,9 @@ class RootWindowContainer extends WindowContainer<DisplayContent>
@Nullable
Task getTopDisplayFocusedRootTask() {
for (int i = getChildCount() - 1; i >= 0; --i) {
final Task focusedStack = getChildAt(i).getFocusedRootTask();
if (focusedStack != null) {
return focusedStack;
final Task focusedRootTask = getChildAt(i).getFocusedRootTask();
if (focusedRootTask != null) {
return focusedRootTask;
}
}
return null;
@@ -1864,15 +1864,15 @@ class RootWindowContainer extends WindowContainer<DisplayContent>
@Nullable
ActivityRecord getTopResumedActivity() {
final Task focusedStack = getTopDisplayFocusedRootTask();
if (focusedStack == null) {
final Task focusedRootTask = getTopDisplayFocusedRootTask();
if (focusedRootTask == null) {
return null;
}
final ActivityRecord resumedActivity = focusedStack.getResumedActivity();
final ActivityRecord resumedActivity = focusedRootTask.getResumedActivity();
if (resumedActivity != null && resumedActivity.app != null) {
return resumedActivity;
}
// The top focused stack might not have a resumed activity yet - look on all displays in
// The top focused root task might not have a resumed activity yet - look on all displays in
// focus order.
return getItemFromTaskDisplayAreas(TaskDisplayArea::getFocusedActivity);
}
@@ -1997,36 +1997,36 @@ class RootWindowContainer extends WindowContainer<DisplayContent>
}
boolean switchUser(int userId, UserState uss) {
final Task topFocusedStack = getTopDisplayFocusedRootTask();
final int focusStackId = topFocusedStack != null
? topFocusedStack.getRootTaskId() : INVALID_TASK_ID;
// We dismiss the docked stack whenever we switch users.
final Task topFocusedRootTask = getTopDisplayFocusedRootTask();
final int focusRootTaskId = topFocusedRootTask != null
? topFocusedRootTask.getRootTaskId() : INVALID_TASK_ID;
// We dismiss the docked root task whenever we switch users.
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
// Also dismiss the pinned root task whenever we switch users. Removing the pinned root task
// will also cause all tasks to be moved to the fullscreen root task at a position that is
// appropriate.
removeRootTasksInWindowingModes(WINDOWING_MODE_PINNED);
mUserRootTaskInFront.put(mCurrentUser, focusStackId);
mUserRootTaskInFront.put(mCurrentUser, focusRootTaskId);
mCurrentUser = userId;
mTaskSupervisor.mStartingUsers.add(uss);
forAllRootTasks(stack -> {
stack.switchUser(userId);
forAllRootTasks(rootTask -> {
rootTask.switchUser(userId);
});
final int restoreStackId = mUserRootTaskInFront.get(userId);
Task stack = getRootTask(restoreStackId);
if (stack == null) {
stack = getDefaultTaskDisplayArea().getOrCreateRootHomeTask();
final int restoreRootTaskId = mUserRootTaskInFront.get(userId);
Task rootTask = getRootTask(restoreRootTaskId);
if (rootTask == null) {
rootTask = getDefaultTaskDisplayArea().getOrCreateRootHomeTask();
}
final boolean homeInFront = stack.isActivityTypeHome();
if (stack.isOnHomeDisplay()) {
stack.moveToFront("switchUserOnHomeDisplay");
final boolean homeInFront = rootTask.isActivityTypeHome();
if (rootTask.isOnHomeDisplay()) {
rootTask.moveToFront("switchUserOnHomeDisplay");
} else {
// Stack was moved to another display while user was swapped out.
// Root task was moved to another display while user was swapped out.
resumeHomeActivity(null, "switchUserOnOtherDisplay", getDefaultTaskDisplayArea());
}
return homeInFront;
@@ -2350,7 +2350,7 @@ class RootWindowContainer extends WindowContainer<DisplayContent>
return result;
}
void applySleepTokens(boolean applyToStacks) {
void applySleepTokens(boolean applyToRootTasks) {
for (int displayNdx = getChildCount() - 1; displayNdx >= 0; --displayNdx) {
// Set the sleeping state of the display.
final DisplayContent display = getChildAt(displayNdx);
@@ -2360,17 +2360,17 @@ class RootWindowContainer extends WindowContainer<DisplayContent>
}
display.setIsSleeping(displayShouldSleep);
if (!applyToStacks) {
if (!applyToRootTasks) {
continue;
}
// Set the sleeping state of the stacks on the display.
display.forAllRootTasks(stack -> {
// Set the sleeping state of the root tasks on the display.
display.forAllRootTasks(rootTask -> {
if (displayShouldSleep) {
stack.goToSleepIfPossible(false /* shuttingDown */);
rootTask.goToSleepIfPossible(false /* shuttingDown */);
} else {
stack.awakeFromSleepingLocked();
if (stack.isFocusedStackOnDisplay()
rootTask.awakeFromSleepingLocked();
if (rootTask.isFocusedStackOnDisplay()
&& !mTaskSupervisor.getKeyguardController()
.isKeyguardOrAodShowing(display.mDisplayId)) {
// If the keyguard is unlocked - resume immediately.
@@ -2378,13 +2378,13 @@ class RootWindowContainer extends WindowContainer<DisplayContent>
// process the keyguard going away, which can happen before the sleep
// token is released. As a result, it is important we resume the
// activity here.
stack.resumeTopActivityUncheckedLocked(null, null);
rootTask.resumeTopActivityUncheckedLocked(null, null);
}
// The visibility update must not be called before resuming the top, so the
// display orientation can be updated first if needed. Otherwise there may
// have redundant configuration changes due to apply outdated display
// orientation (from keyguard) to activity.
stack.ensureActivitiesVisible(null /* starting */, 0 /* configChanges */,
rootTask.ensureActivitiesVisible(null /* starting */, 0 /* configChanges */,
false /* preserveWindows */);
}
});
@@ -2427,7 +2427,7 @@ class RootWindowContainer extends WindowContainer<DisplayContent>
task.fillTaskInfo(info);
// A task might be not attached to a display.
info.position = taskDisplayArea != null ? taskDisplayArea.getIndexOf(task) : 0;
info.position = taskDisplayArea != null ? taskDisplayArea.getTaskIndexOf(task) : 0;
info.visible = task.shouldBeVisible(null);
task.getBounds(info.bounds);
@@ -2471,21 +2471,21 @@ class RootWindowContainer extends WindowContainer<DisplayContent>
}
RootTaskInfo getRootTaskInfo(int windowingMode, int activityType) {
final Task stack = getRootTask(windowingMode, activityType);
return (stack != null) ? getRootTaskInfo(stack) : null;
final Task rootTask = getRootTask(windowingMode, activityType);
return (rootTask != null) ? getRootTaskInfo(rootTask) : null;
}
RootTaskInfo getRootTaskInfo(int windowingMode, int activityType, int displayId) {
final Task stack = getRootTask(windowingMode, activityType, displayId);
return (stack != null) ? getRootTaskInfo(stack) : null;
final Task rootTask = getRootTask(windowingMode, activityType, displayId);
return (rootTask != null) ? getRootTaskInfo(rootTask) : null;
}
/** If displayId == INVALID_DISPLAY, this will get root task infos on all displays */
ArrayList<RootTaskInfo> getAllRootTaskInfos(int displayId) {
final ArrayList<RootTaskInfo> list = new ArrayList<>();
if (displayId == INVALID_DISPLAY) {
forAllRootTasks(stack -> {
list.add(getRootTaskInfo(stack));
forAllRootTasks(rootTask -> {
list.add(getRootTaskInfo(rootTask));
});
return list;
}
@@ -2493,8 +2493,8 @@ class RootWindowContainer extends WindowContainer<DisplayContent>
if (display == null) {
return list;
}
display.forAllRootTasks(stack -> {
list.add(getRootTaskInfo(stack));
display.forAllRootTasks(rootTask -> {
list.add(getRootTaskInfo(rootTask));
});
return list;
}
@@ -2955,8 +2955,8 @@ class RootWindowContainer extends WindowContainer<DisplayContent>
}
// If {@code r} is already in target display area and its task is the same as the candidate
// task, the intention should be getting a launch stack for the reusable activity, so we can
// use the existing stack.
// task, the intention should be getting a launch root task for the reusable activity, so we
// can use the existing root task.
if (candidateTask != null) {
final TaskDisplayArea attachedTaskDisplayArea = candidateTask.getDisplayArea();
if (attachedTaskDisplayArea == null || attachedTaskDisplayArea == taskDisplayArea) {
@@ -2965,9 +2965,9 @@ class RootWindowContainer extends WindowContainer<DisplayContent>
// Or the candidate task is already a root task that can be reused by reparenting
// it to the target display.
if (candidateTask.isRootTask()) {
final Task stack = candidateTask.getRootTask();
stack.reparent(taskDisplayArea, true /* onTop */);
return stack;
final Task rootTask = candidateTask.getRootTask();
rootTask.reparent(taskDisplayArea, true /* onTop */);
return rootTask;
}
}
@@ -2984,16 +2984,16 @@ class RootWindowContainer extends WindowContainer<DisplayContent>
windowingMode = taskDisplayArea.validateWindowingMode(windowingMode, r, candidateTask,
r.getActivityType());
// Return the topmost valid stack on the display.
// Return the topmost valid root task on the display.
final int targetWindowingMode = windowingMode;
final Task topmostValidStack = taskDisplayArea.getRootTask(stack ->
isValidLaunchRootTask(stack, r, targetWindowingMode));
if (topmostValidStack != null) {
return topmostValidStack;
final Task topmostValidRootTask = taskDisplayArea.getRootTask(rootTask ->
isValidLaunchRootTask(rootTask, r, targetWindowingMode));
if (topmostValidRootTask != null) {
return topmostValidRootTask;
}
// If there is no valid stack on the secondary display area - check if new dynamic stack
// will do.
// If there is no valid root task on the secondary display area - check if new dynamic root
// task will do.
if (taskDisplayArea != getDisplayContent(taskDisplayArea.getDisplayId())
.getDefaultTaskDisplayArea()) {
final int activityType =
@@ -3224,8 +3224,8 @@ class RootWindowContainer extends WindowContainer<DisplayContent>
}
void finishVoiceTask(IVoiceInteractionSession session) {
forAllRootTasks(stack -> {
stack.finishVoiceTask(session);
forAllRootTasks(rootTask -> {
rootTask.finishVoiceTask(session);
});
}
@@ -3284,8 +3284,8 @@ class RootWindowContainer extends WindowContainer<DisplayContent>
boolean allResumedActivitiesVisible() {
boolean[] foundResumed = {false};
final boolean foundInvisibleResumedActivity = forAllRootTasks(stack -> {
final ActivityRecord r = stack.getResumedActivity();
final boolean foundInvisibleResumedActivity = forAllRootTasks(rootTask -> {
final ActivityRecord r = rootTask.getResumedActivity();
if (r != null) {
if (!r.nowVisible) {
return true;
@@ -3529,9 +3529,9 @@ class RootWindowContainer extends WindowContainer<DisplayContent>
}
} else {
final ArrayList<ActivityRecord> activities = new ArrayList<>();
forAllRootTasks(stack -> {
if (!dumpVisibleStacksOnly || stack.shouldBeVisible(null)) {
activities.addAll(stack.getDumpActivitiesLocked(name));
forAllRootTasks(rootTask -> {
if (!dumpVisibleStacksOnly || rootTask.shouldBeVisible(null)) {
activities.addAll(rootTask.getDumpActivitiesLocked(name));
}
});
return activities;
@@ -3581,11 +3581,11 @@ class RootWindowContainer extends WindowContainer<DisplayContent>
pw.print("Display #");
pw.print(displayContent.mDisplayId);
pw.println(" (activities from top to bottom):");
displayContent.forAllRootTasks(stack -> {
displayContent.forAllRootTasks(rootTask -> {
if (needSep[0]) {
pw.println();
}
needSep[0] = stack.dump(fd, pw, dumpAll, dumpClient, dumpPackage, false);
needSep[0] = rootTask.dump(fd, pw, dumpAll, dumpClient, dumpPackage, false);
printed[0] |= needSep[0];
});
displayContent.forAllTaskDisplayAreas(taskDisplayArea -> {

38
services/core/java/com/android/server/wm/Task.java
View File

@@ -5318,20 +5318,19 @@ class Task extends WindowContainer<WindowContainer> {
final TaskDisplayArea taskDisplayArea = getDisplayArea();
if (inSplitScreenSecondaryWindowingMode()) {
// If the stack is in split-screen secondary mode, we need to make sure we move the
// primary split-screen stack forward in the case it is currently behind a fullscreen
// stack so both halves of the split-screen appear on-top and the fullscreen stack isn't
// cutting between them.
// If the root task is in split-screen secondary mode, we need to make sure we move the
// primary split-screen root task forward in the case it is currently behind a
// fullscreen root task so both halves of the split-screen appear on-top and the
// fullscreen root task isn't cutting between them.
// TODO(b/70677280): This is a workaround until we can fix as part of b/70677280.
final Task topFullScreenStack =
final Task topFullScreenRootTask =
taskDisplayArea.getTopRootTaskInWindowingMode(WINDOWING_MODE_FULLSCREEN);
if (topFullScreenStack != null) {
final Task primarySplitScreenStack =
if (topFullScreenRootTask != null) {
final Task primarySplitScreenRootTask =
taskDisplayArea.getRootSplitScreenPrimaryTask();
if (primarySplitScreenStack != null
&& taskDisplayArea.getIndexOf(topFullScreenStack)
> taskDisplayArea.getIndexOf(primarySplitScreenStack)) {
primarySplitScreenStack.moveToFront(reason + " splitScreenToTop");
if (primarySplitScreenRootTask != null
&& topFullScreenRootTask.compareTo(primarySplitScreenRootTask) > 0) {
primarySplitScreenRootTask.moveToFront(reason + " splitScreenToTop");
}
}
}
@@ -5746,7 +5745,7 @@ class Task extends WindowContainer<WindowContainer> {
}
/**
* @return {@code true} if this is the focused stack on its current display, {@code false}
* @return {@code true} if this is the focused root task on its current display, {@code false}
* otherwise.
*/
boolean isFocusedStackOnDisplay() {
@@ -6698,18 +6697,21 @@ class Task extends WindowContainer<WindowContainer> {
});
}
/** @return true if the stack behind this one is a standard activity type. */
private boolean inFrontOfStandardStack() {
/** @return true if the root task behind this one is a standard activity type. */
private boolean inFrontOfStandardRootTask() {
final TaskDisplayArea taskDisplayArea = getDisplayArea();
if (taskDisplayArea == null) {
return false;
}
final int index = taskDisplayArea.getIndexOf(this);
final int index = taskDisplayArea.getTaskIndexOf(this);
if (index == 0) {
return false;
}
final Task stackBehind = taskDisplayArea.getChildAt(index - 1);
return stackBehind.isActivityTypeStandard();
final int[] indexCount = new int[1];
final Task rootTaskBehind = taskDisplayArea.getRootTask(
// From bottom to top, find the one behind this Task.
task -> ++indexCount[0] == index, false /* traverseTopToBottom */);
return rootTaskBehind.isActivityTypeStandard();
}
boolean shouldUpRecreateTaskLocked(ActivityRecord srec, String destAffinity) {
@@ -6730,7 +6732,7 @@ class Task extends WindowContainer<WindowContainer> {
if (srec.isRootOfTask() && task.getBaseIntent() != null
&& task.getBaseIntent().isDocument()) {
// Okay, this activity is at the root of its task. What to do, what to do...
if (!inFrontOfStandardStack()) {
if (!inFrontOfStandardRootTask()) {
// Finishing won't return to an application, so we need to recreate.
return true;
}

642
services/core/java/com/android/server/wm/TaskDisplayArea.java
View File

File diff suppressed because it is too large Load Diff

14
services/tests/wmtests/src/com/android/server/wm/ActivityDisplayTests.java
View File

@@ -248,7 +248,7 @@ public class ActivityDisplayTests extends WindowTestsBase {
int topPosition = taskDisplayArea.getRootTaskCount() - 1;
// Ensure the new alwaysOnTop stack is put below the pinned stack, but on top of the
// existing alwaysOnTop stack.
assertEquals(topPosition - 1, taskDisplayArea.getIndexOf(anotherAlwaysOnTopStack));
assertEquals(topPosition - 1, taskDisplayArea.getTaskIndexOf(anotherAlwaysOnTopStack));
final Task nonAlwaysOnTopStack = taskDisplayArea.createRootTask(
WINDOWING_MODE_FREEFORM, ACTIVITY_TYPE_STANDARD, true /* onTop */);
@@ -256,7 +256,7 @@ public class ActivityDisplayTests extends WindowTestsBase {
topPosition = taskDisplayArea.getRootTaskCount() - 1;
// Ensure the non-alwaysOnTop stack is put below the three alwaysOnTop stacks, but above the
// existing other non-alwaysOnTop stacks.
assertEquals(topPosition - 3, taskDisplayArea.getIndexOf(nonAlwaysOnTopStack));
assertEquals(topPosition - 3, taskDisplayArea.getTaskIndexOf(nonAlwaysOnTopStack));
anotherAlwaysOnTopStack.setAlwaysOnTop(false);
taskDisplayArea.positionChildAt(POSITION_TOP, anotherAlwaysOnTopStack,
@@ -264,16 +264,16 @@ public class ActivityDisplayTests extends WindowTestsBase {
assertFalse(anotherAlwaysOnTopStack.isAlwaysOnTop());
// Ensure, when always on top is turned off for a stack, the stack is put just below all
// other always on top stacks.
assertEquals(topPosition - 2, taskDisplayArea.getIndexOf(anotherAlwaysOnTopStack));
assertEquals(topPosition - 2, taskDisplayArea.getTaskIndexOf(anotherAlwaysOnTopStack));
anotherAlwaysOnTopStack.setAlwaysOnTop(true);
// Ensure always on top state changes properly when windowing mode changes.
anotherAlwaysOnTopStack.setWindowingMode(WINDOWING_MODE_FULLSCREEN);
assertFalse(anotherAlwaysOnTopStack.isAlwaysOnTop());
assertEquals(topPosition - 2, taskDisplayArea.getIndexOf(anotherAlwaysOnTopStack));
assertEquals(topPosition - 2, taskDisplayArea.getTaskIndexOf(anotherAlwaysOnTopStack));
anotherAlwaysOnTopStack.setWindowingMode(WINDOWING_MODE_FREEFORM);
assertTrue(anotherAlwaysOnTopStack.isAlwaysOnTop());
assertEquals(topPosition - 1, taskDisplayArea.getIndexOf(anotherAlwaysOnTopStack));
assertEquals(topPosition - 1, taskDisplayArea.getTaskIndexOf(anotherAlwaysOnTopStack));
final Task dreamStack = taskDisplayArea.createRootTask(
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_DREAM, true /* onTop */);
@@ -282,7 +282,7 @@ public class ActivityDisplayTests extends WindowTestsBase {
topPosition = taskDisplayArea.getRootTaskCount() - 1;
// Ensure dream shows above all activities, including PiP
assertEquals(dreamStack, taskDisplayArea.getTopRootTask());
assertEquals(topPosition - 1, taskDisplayArea.getIndexOf(pinnedStack));
assertEquals(topPosition - 1, taskDisplayArea.getTaskIndexOf(pinnedStack));
final Task assistStack = taskDisplayArea.createRootTask(
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_ASSISTANT, true /* onTop */);
@@ -295,7 +295,7 @@ public class ActivityDisplayTests extends WindowTestsBase {
final boolean isAssistantOnTop = mContext.getResources()
.getBoolean(com.android.internal.R.bool.config_assistantOnTopOfDream);
assertEquals(isAssistantOnTop ? topPosition : topPosition - 4,
taskDisplayArea.getIndexOf(assistStack));
taskDisplayArea.getTaskIndexOf(assistStack));
}
@Test

18
services/tests/wmtests/src/com/android/server/wm/ActivityStackTests.java
View File

@@ -167,7 +167,7 @@ public class ActivityStackTests extends WindowTestsBase {
null /* task */);
// Assert that stack is at the bottom.
assertEquals(0, mDefaultTaskDisplayArea.getIndexOf(primarySplitScreen));
assertEquals(0, mDefaultTaskDisplayArea.getTaskIndexOf(primarySplitScreen));
// Ensure no longer in splitscreen.
assertEquals(WINDOWING_MODE_FULLSCREEN, primarySplitScreen.getWindowingMode());
@@ -748,10 +748,10 @@ public class ActivityStackTests extends WindowTestsBase {
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 = mDefaultTaskDisplayArea.getIndexOf(homeStack);
int homeStackIndex = mDefaultTaskDisplayArea.getTaskIndexOf(homeStack);
assertEquals(fullscreenStack, getRootTaskAbove(homeStack));
mDefaultTaskDisplayArea.moveRootTaskBehindBottomMostVisibleRootTask(homeStack);
assertEquals(homeStackIndex, mDefaultTaskDisplayArea.getIndexOf(homeStack));
assertEquals(homeStackIndex, mDefaultTaskDisplayArea.getTaskIndexOf(homeStack));
}
@Test
@@ -766,10 +766,10 @@ public class ActivityStackTests extends WindowTestsBase {
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 = mDefaultTaskDisplayArea.getIndexOf(homeStack);
int homeStackIndex = mDefaultTaskDisplayArea.getTaskIndexOf(homeStack);
assertEquals(fullscreenStack, getRootTaskAbove(homeStack));
mDefaultTaskDisplayArea.moveRootTaskBehindBottomMostVisibleRootTask(homeStack);
assertEquals(homeStackIndex, mDefaultTaskDisplayArea.getIndexOf(homeStack));
assertEquals(homeStackIndex, mDefaultTaskDisplayArea.getTaskIndexOf(homeStack));
}
@Test
@@ -784,10 +784,10 @@ public class ActivityStackTests extends WindowTestsBase {
doReturn(false).when(fullscreenStack).isTranslucent(any());
// Ensure we don't move the home stack if it is already on top
int homeStackIndex = mDefaultTaskDisplayArea.getIndexOf(homeStack);
int homeStackIndex = mDefaultTaskDisplayArea.getTaskIndexOf(homeStack);
assertNull(getRootTaskAbove(homeStack));
mDefaultTaskDisplayArea.moveRootTaskBehindBottomMostVisibleRootTask(homeStack);
assertEquals(homeStackIndex, mDefaultTaskDisplayArea.getIndexOf(homeStack));
assertEquals(homeStackIndex, mDefaultTaskDisplayArea.getTaskIndexOf(homeStack));
}
@Test
@@ -853,9 +853,9 @@ public class ActivityStackTests extends WindowTestsBase {
doReturn(false).when(fullscreenStack2).isTranslucent(any());
// Ensure we don't move the home stack behind itself
int homeStackIndex = mDefaultTaskDisplayArea.getIndexOf(homeStack);
int homeStackIndex = mDefaultTaskDisplayArea.getTaskIndexOf(homeStack);
mDefaultTaskDisplayArea.moveRootTaskBehindRootTask(homeStack, homeStack);
assertEquals(homeStackIndex, mDefaultTaskDisplayArea.getIndexOf(homeStack));
assertEquals(homeStackIndex, mDefaultTaskDisplayArea.getTaskIndexOf(homeStack));
}
@Test

4
services/tests/wmtests/src/com/android/server/wm/ActivityStarterTests.java
View File

@@ -512,8 +512,8 @@ public class ActivityStarterTests extends WindowTestsBase {
}
private void assertNoTasks(DisplayContent display) {
display.forAllRootTasks(stack -> {
assertFalse(stack.hasChild());
display.forAllRootTasks(rootTask -> {
assertFalse(rootTask.hasChild());
});
}

4
services/tests/wmtests/src/com/android/server/wm/DisplayAreaPolicyBuilderTest.java
View File

@@ -702,7 +702,7 @@ public class DisplayAreaPolicyBuilderTest {
private Map<DisplayArea<?>, Set<Integer>> calculateZSets(
DisplayAreaPolicyBuilder.Result policy,
DisplayArea.Tokens ime,
DisplayArea<Task> tasks) {
TaskDisplayArea taskDisplayArea) {
Map<DisplayArea<?>, Set<Integer>> zSets = new HashMap<>();
int[] types = {TYPE_STATUS_BAR, TYPE_NAVIGATION_BAR, TYPE_PRESENTATION,
TYPE_APPLICATION_OVERLAY};
@@ -710,7 +710,7 @@ public class DisplayAreaPolicyBuilderTest {
WindowToken token = tokenOfType(type);
recordLayer(policy.findAreaForToken(token), token.getWindowLayerFromType(), zSets);
}
recordLayer(tasks, APPLICATION_LAYER, zSets);
recordLayer(taskDisplayArea, APPLICATION_LAYER, zSets);
recordLayer(ime, mPolicy.getWindowLayerFromTypeLw(TYPE_INPUT_METHOD), zSets);
return zSets;
}

6
services/tests/wmtests/src/com/android/server/wm/WindowTestsBase.java
View File

@@ -1121,9 +1121,9 @@ class WindowTestsBase extends SystemServiceTestsBase {
mService.mTaskOrganizerController.setLaunchRoot(mDisplayId,
mSecondary.mRemoteToken.toWindowContainerToken());
DisplayContent dc = mService.mRootWindowContainer.getDisplayContent(mDisplayId);
dc.forAllRootTasks(stack -> {
if (!WindowConfiguration.isSplitScreenWindowingMode(stack.getWindowingMode())) {
stack.reparent(mSecondary, POSITION_BOTTOM);
dc.forAllRootTasks(rootTask -> {
if (!WindowConfiguration.isSplitScreenWindowingMode(rootTask.getWindowingMode())) {
rootTask.reparent(mSecondary, POSITION_BOTTOM);
}
});
}