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

Merge "Refactor TestSplitOrganizer and remove useless code"

Browse Source
This commit is contained in:
Tony Huang
2022-01-19 08:12:01 +00:00
committed by Android (Google) Code Review
parent 20ba147a11 c96cfffa84
commit d6b531e627
5 changed files with 75 additions and 247 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -4629,25 +4629,7 @@ class Task extends TaskFragment {
}
void moveToFront(String reason, Task task) {
if (inSplitScreenSecondaryWindowingMode()) {
// 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 TaskDisplayArea taskDisplayArea = getDisplayArea();
final Task topFullScreenRootTask =
taskDisplayArea.getTopRootTaskInWindowingMode(WINDOWING_MODE_FULLSCREEN);
if (topFullScreenRootTask != null) {
final Task primarySplitScreenRootTask =
taskDisplayArea.getRootSplitScreenPrimaryTask();
if (primarySplitScreenRootTask != null
&& topFullScreenRootTask.compareTo(primarySplitScreenRootTask) > 0) {
primarySplitScreenRootTask.moveToFrontInner(reason + " splitScreenToTop",
null /* task */);
}
}
} else if (mMoveAdjacentTogether && getAdjacentTaskFragment() != null) {
if (mMoveAdjacentTogether && getAdjacentTaskFragment() != null) {
final Task adjacentTask = getAdjacentTaskFragment().asTask();
if (adjacentTask != null) {
adjacentTask.moveToFrontInner(reason + " adjacentTaskToTop", null /* task */);

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

@@ -31,7 +31,6 @@ import static android.app.ActivityManager.START_TASK_TO_FRONT;
import static android.app.WindowConfiguration.ACTIVITY_TYPE_STANDARD;
import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
import static android.app.WindowConfiguration.WINDOWING_MODE_PINNED;
import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_PRIMARY;
import static android.content.Intent.FLAG_ACTIVITY_CLEAR_TASK;
import static android.content.Intent.FLAG_ACTIVITY_LAUNCH_ADJACENT;
import static android.content.Intent.FLAG_ACTIVITY_NEW_TASK;
@@ -51,7 +50,6 @@ import static com.android.dx.mockito.inline.extended.ExtendedMockito.spy;
import static com.android.dx.mockito.inline.extended.ExtendedMockito.spyOn;
import static com.android.dx.mockito.inline.extended.ExtendedMockito.times;
import static com.android.dx.mockito.inline.extended.ExtendedMockito.verify;
import static com.android.server.wm.ActivityTaskSupervisor.PRESERVE_WINDOWS;
import static com.android.server.wm.WindowContainer.POSITION_BOTTOM;
import static com.android.server.wm.WindowContainer.POSITION_TOP;
@@ -457,7 +455,7 @@ public class ActivityStarterTests extends WindowTestsBase {
final ActivityRecord splitSecondReusableActivity = activities.second;
final ActivityRecord splitSecondTopActivity = new ActivityBuilder(mAtm).setCreateTask(true)
.setParentTask(splitSecondReusableActivity.getRootTask()).build();
assertTrue(splitSecondTopActivity.inSplitScreenSecondaryWindowingMode());
assertTrue(splitSecondTopActivity.inMultiWindowMode());
// Let primary stack has focus.
splitPrimaryFocusActivity.moveFocusableActivityToTop("testSplitScreenTaskToFront");
@@ -476,13 +474,16 @@ public class ActivityStarterTests extends WindowTestsBase {
final TestSplitOrganizer splitOrg = new TestSplitOrganizer(mAtm);
// The fullscreen windowing mode activity will be moved to split-secondary by
// TestSplitOrganizer when a split-primary task appears.
final ActivityRecord splitSecondActivity =
new ActivityBuilder(mAtm).setCreateTask(true).build();
final ActivityRecord splitPrimaryActivity = new TaskBuilder(mSupervisor)
.setParentTaskFragment(splitOrg.mPrimary)
.setCreateActivity(true)
.build()
.getTopMostActivity();
final ActivityRecord splitSecondActivity = new TaskBuilder(mSupervisor)
.setParentTaskFragment(splitOrg.mSecondary)
.setCreateActivity(true)
.build()
.getTopMostActivity();
splitPrimaryActivity.mVisibleRequested = splitSecondActivity.mVisibleRequested = true;
assertEquals(splitOrg.mPrimary, splitPrimaryActivity.getRootTask());
@@ -1090,7 +1091,7 @@ public class ActivityStarterTests extends WindowTestsBase {
starter.setActivityOptions(options.toBundle())
.setReason("testWindowingModeOptionsLaunchAdjacent")
.setOutActivity(outActivity).execute();
assertThat(outActivity[0].inSplitScreenSecondaryWindowingMode()).isTrue();
assertThat(outActivity[0].inMultiWindowMode()).isTrue();
}
@Test
@@ -1107,50 +1108,6 @@ public class ActivityStarterTests extends WindowTestsBase {
verify(recentTasks, times(1)).add(any());
}
@Test
public void testStartActivityInner_allSplitScreenPrimaryActivitiesVisible() {
// Given
final ActivityStarter starter = prepareStarter(0, false);
starter.setReason("testAllSplitScreenPrimaryActivitiesAreResumed");
final ActivityRecord targetRecord = new ActivityBuilder(mAtm).build();
targetRecord.setFocusable(false);
targetRecord.setVisibility(false);
final ActivityRecord sourceRecord = new ActivityBuilder(mAtm).build();
final Task stack = spy(
mRootWindowContainer.getDefaultTaskDisplayArea()
.createRootTask(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, ACTIVITY_TYPE_STANDARD,
/* onTop */true));
stack.addChild(targetRecord);
doReturn(stack).when(mRootWindowContainer).getLaunchRootTask(any(), any(), any(), any(),
anyBoolean(), any(), anyInt(), anyInt(), anyInt());
starter.mStartActivity = new ActivityBuilder(mAtm).build();
// When
starter.startActivityInner(
/* r */targetRecord,
/* sourceRecord */ sourceRecord,
/* voiceSession */null,
/* voiceInteractor */ null,
/* startFlags */ 0,
/* doResume */true,
/* options */null,
/* inTask */null,
/* inTaskFragment */ null,
/* restrictedBgActivity */false,
/* intentGrants */null);
// Then
verify(stack).ensureActivitiesVisible(null, 0, !PRESERVE_WINDOWS);
verify(targetRecord).makeVisibleIfNeeded(null, true);
assertTrue(targetRecord.mVisibleRequested);
}
@Test
public void testStartActivityInner_inTaskFragment() {
final ActivityStarter starter = prepareStarter(0, false);

145
services/tests/wmtests/src/com/android/server/wm/RootTaskTests.java
View File

@@ -22,6 +22,7 @@ import static android.app.WindowConfiguration.ACTIVITY_TYPE_STANDARD;
import static android.app.WindowConfiguration.ACTIVITY_TYPE_UNDEFINED;
import static android.app.WindowConfiguration.WINDOWING_MODE_FREEFORM;
import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
import static android.app.WindowConfiguration.WINDOWING_MODE_MULTI_WINDOW;
import static android.app.WindowConfiguration.WINDOWING_MODE_PINNED;
import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_PRIMARY;
import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_SECONDARY;
@@ -240,7 +241,7 @@ public class RootTaskTests extends WindowTestsBase {
final WindowConfiguration windowConfiguration =
task.getResolvedOverrideConfiguration().windowConfiguration;
spyOn(windowConfiguration);
doReturn(WINDOWING_MODE_SPLIT_SCREEN_SECONDARY)
doReturn(WINDOWING_MODE_MULTI_WINDOW)
.when(windowConfiguration).getWindowingMode();
// Prevent adjust task dimensions
@@ -322,73 +323,13 @@ public class RootTaskTests extends WindowTestsBase {
assertEquals(r, destRootTask.getTopResumedActivity());
}
@Test
public void testPrimarySplitScreenMoveToBack() {
TestSplitOrganizer organizer = new TestSplitOrganizer(mAtm);
// We're testing an edge case here where we have primary + fullscreen rather than secondary.
organizer.setMoveToSecondaryOnEnter(false);
// Create primary splitscreen root task.
final Task primarySplitScreen = new TaskBuilder(mAtm.mTaskSupervisor)
.setParentTaskFragment(organizer.mPrimary)
.setOnTop(true)
.build();
// Assert windowing mode.
assertEquals(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, primarySplitScreen.getWindowingMode());
// Move primary to back.
primarySplitScreen.moveToBack("testPrimarySplitScreenToFullscreenWhenMovedToBack",
null /* task */);
// Assert that root task is at the bottom.
assertEquals(0, getTaskIndexOf(mDefaultTaskDisplayArea, primarySplitScreen));
// Ensure no longer in splitscreen.
assertEquals(WINDOWING_MODE_FULLSCREEN, primarySplitScreen.getWindowingMode());
// Ensure that the override mode is restored to undefined
assertEquals(WINDOWING_MODE_UNDEFINED,
primarySplitScreen.getRequestedOverrideWindowingMode());
}
@Test
public void testMoveToPrimarySplitScreenThenMoveToBack() {
TestSplitOrganizer organizer = new TestSplitOrganizer(mAtm);
// This time, start with a fullscreen activity root task.
final Task primarySplitScreen = mDefaultTaskDisplayArea.createRootTask(
WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_STANDARD, true /* onTop */);
primarySplitScreen.reparent(organizer.mPrimary, POSITION_TOP,
false /*moveParents*/, "test");
// Assert windowing mode.
assertEquals(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, primarySplitScreen.getWindowingMode());
// Move primary to back.
primarySplitScreen.moveToBack("testPrimarySplitScreenToFullscreenWhenMovedToBack",
null /* task */);
// Assert that root task is at the bottom.
assertEquals(primarySplitScreen, organizer.mSecondary.getChildAt(0));
// Ensure that the override mode is restored to what it was (fullscreen)
assertEquals(WINDOWING_MODE_UNDEFINED,
primarySplitScreen.getRequestedOverrideWindowingMode());
}
@Test
public void testSplitScreenMoveToBack() {
TestSplitOrganizer organizer = new TestSplitOrganizer(mAtm);
// Explicitly reparent task to primary split root to enter split mode, in which implies
// primary on top and secondary containing the home task below another root task.
final Task primaryTask = mDefaultTaskDisplayArea.createRootTask(
WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_STANDARD, true /* onTop */);
final Task secondaryTask = mDefaultTaskDisplayArea.createRootTask(
WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_STANDARD, true /* onTop */);
final Task primaryTask = organizer.createTaskToPrimary(true /* onTop */);
final Task secondaryTask = organizer.createTaskToSecondary(true /* onTop */);
final Task homeRoot = mDefaultTaskDisplayArea.getRootTask(
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_HOME);
primaryTask.reparent(organizer.mPrimary, POSITION_TOP);
mDefaultTaskDisplayArea.positionChildAt(POSITION_TOP, organizer.mPrimary,
false /* includingParents */);
@@ -397,21 +338,26 @@ public class RootTaskTests extends WindowTestsBase {
// Assert that the primaryTask is now below home in its parent but primary is left alone.
assertEquals(0, organizer.mPrimary.getChildCount());
assertEquals(primaryTask, organizer.mSecondary.getChildAt(0));
// Assert that root task is at the bottom.
assertEquals(0, getTaskIndexOf(mDefaultTaskDisplayArea, primaryTask));
assertEquals(1, organizer.mPrimary.compareTo(organizer.mSecondary));
assertEquals(1, homeRoot.compareTo(primaryTask));
assertEquals(homeRoot.getParent(), primaryTask.getParent());
// Make sure windowing modes are correct
assertEquals(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, organizer.mPrimary.getWindowingMode());
assertEquals(WINDOWING_MODE_SPLIT_SCREEN_SECONDARY, primaryTask.getWindowingMode());
assertEquals(WINDOWING_MODE_MULTI_WINDOW, organizer.mPrimary.getWindowingMode());
assertEquals(WINDOWING_MODE_MULTI_WINDOW, secondaryTask.getWindowingMode());
// Ensure no longer in splitscreen.
assertEquals(WINDOWING_MODE_FULLSCREEN, primaryTask.getWindowingMode());
// Ensure that the override mode is restored to undefined
assertEquals(WINDOWING_MODE_UNDEFINED, primaryTask.getRequestedOverrideWindowingMode());
// Move secondary to back via parent (should be equivalent)
organizer.mSecondary.moveToBack("test", secondaryTask);
// Assert that it is now in back but still in secondary split
// Assert that it is now in back and left in secondary split
assertEquals(0, organizer.mSecondary.getChildCount());
assertEquals(1, homeRoot.compareTo(primaryTask));
assertEquals(secondaryTask, organizer.mSecondary.getChildAt(0));
assertEquals(1, primaryTask.compareTo(secondaryTask));
assertEquals(homeRoot.getParent(), secondaryTask.getParent());
}
@@ -423,7 +369,7 @@ public class RootTaskTests extends WindowTestsBase {
.setTask(rootHomeTask)
.build();
final Task secondaryRootTask = mAtm.mTaskOrganizerController.createRootTask(
rootHomeTask.getDisplayContent(), WINDOWING_MODE_SPLIT_SCREEN_SECONDARY, null);
rootHomeTask.getDisplayContent(), WINDOWING_MODE_MULTI_WINDOW, null);
rootHomeTask.reparent(secondaryRootTask, POSITION_TOP);
assertEquals(secondaryRootTask, rootHomeTask.getParent());
@@ -581,6 +527,7 @@ public class RootTaskTests extends WindowTestsBase {
assertTrue(pinnedRootTask.shouldBeVisible(null /* starting */));
}
// TODO(b/199236198): check this is unnecessary or need to migrate after remove legacy split.
@Test
public void testShouldBeVisible_SplitScreen() {
// task not supporting split should be fullscreen for this test.
@@ -700,30 +647,23 @@ public class RootTaskTests extends WindowTestsBase {
@Test
public void testGetVisibility_MultiLevel() {
final Task homeRootTask = createTaskForShouldBeVisibleTest(mDefaultTaskDisplayArea,
WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_HOME, true /* onTop */);
TestSplitOrganizer organizer = new TestSplitOrganizer(mAtm);
final Task splitPrimary = createTaskForShouldBeVisibleTest(mDefaultTaskDisplayArea,
WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, ACTIVITY_TYPE_UNDEFINED, true /* onTop */);
// Creating as two-level tasks so home task can be reparented to split-secondary root task.
WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_UNDEFINED, true /* onTop */);
final Task splitSecondary = createTaskForShouldBeVisibleTest(mDefaultTaskDisplayArea,
WINDOWING_MODE_SPLIT_SCREEN_SECONDARY, ACTIVITY_TYPE_UNDEFINED, true /* onTop */,
true /* twoLevelTask */);
WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_UNDEFINED, true /* onTop */);
doReturn(false).when(homeRootTask).isTranslucent(any());
doReturn(false).when(splitPrimary).isTranslucent(any());
doReturn(false).when(splitSecondary).isTranslucent(any());
// Re-parent home to split secondary.
homeRootTask.reparent(splitSecondary, POSITION_TOP);
// Current tasks should be visible.
// Re-parent tasks to split.
organizer.putTaskToPrimary(splitPrimary, true /* onTop */);
organizer.putTaskToSecondary(splitSecondary, true /* onTop */);
// Reparented tasks should be visible.
assertEquals(TASK_FRAGMENT_VISIBILITY_VISIBLE,
splitPrimary.getVisibility(null /* starting */));
assertEquals(TASK_FRAGMENT_VISIBILITY_VISIBLE,
splitSecondary.getVisibility(null /* starting */));
// Home task should still be visible even though it is a child of another visible task.
assertEquals(TASK_FRAGMENT_VISIBILITY_VISIBLE,
homeRootTask.getVisibility(null /* starting */));
// Add fullscreen translucent task that partially occludes split tasks
final Task translucentRootTask = createStandardRootTaskForVisibilityTest(
@@ -736,19 +676,12 @@ public class RootTaskTests extends WindowTestsBase {
splitPrimary.getVisibility(null /* starting */));
assertEquals(TASK_FRAGMENT_VISIBILITY_VISIBLE_BEHIND_TRANSLUCENT,
splitSecondary.getVisibility(null /* starting */));
// Home task should be visible behind translucent since its parent is visible behind
// translucent.
assertEquals(TASK_FRAGMENT_VISIBILITY_VISIBLE_BEHIND_TRANSLUCENT,
homeRootTask.getVisibility(null /* starting */));
// Hide split-secondary
splitSecondary.setForceHidden(FLAG_FORCE_HIDDEN_FOR_TASK_ORG, true /* set */);
organizer.mSecondary.setForceHidden(FLAG_FORCE_HIDDEN_FOR_TASK_ORG, true /* set */);
// Home split secondary and home task should be invisible.
assertEquals(TASK_FRAGMENT_VISIBILITY_INVISIBLE,
splitSecondary.getVisibility(null /* starting */));
assertEquals(TASK_FRAGMENT_VISIBILITY_INVISIBLE,
homeRootTask.getVisibility(null /* starting */));
}
@Test
@@ -1094,36 +1027,6 @@ public class RootTaskTests extends WindowTestsBase {
assertEquals(pinnedRootTask, getRootTaskAbove(alwaysOnTopRootTask2));
}
@Test
public void testSplitScreenMoveToFront() {
final Task splitScreenPrimary = createTaskForShouldBeVisibleTest(mDefaultTaskDisplayArea,
WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, ACTIVITY_TYPE_STANDARD, true /* onTop */);
final Task splitScreenSecondary = createTaskForShouldBeVisibleTest(mDefaultTaskDisplayArea,
WINDOWING_MODE_SPLIT_SCREEN_SECONDARY, ACTIVITY_TYPE_STANDARD, true /* onTop */);
final Task assistantRootTask = createTaskForShouldBeVisibleTest(mDefaultTaskDisplayArea,
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_ASSISTANT, true /* onTop */);
doReturn(false).when(splitScreenPrimary).isTranslucent(any());
doReturn(false).when(splitScreenSecondary).isTranslucent(any());
doReturn(false).when(assistantRootTask).isTranslucent(any());
assertFalse(splitScreenPrimary.shouldBeVisible(null /* starting */));
assertFalse(splitScreenSecondary.shouldBeVisible(null /* starting */));
assertTrue(assistantRootTask.shouldBeVisible(null /* starting */));
splitScreenSecondary.moveToFront("testSplitScreenMoveToFront");
if (isAssistantOnTop()) {
assertFalse(splitScreenPrimary.shouldBeVisible(null /* starting */));
assertFalse(splitScreenSecondary.shouldBeVisible(null /* starting */));
assertTrue(assistantRootTask.shouldBeVisible(null /* starting */));
} else {
assertTrue(splitScreenPrimary.shouldBeVisible(null /* starting */));
assertTrue(splitScreenSecondary.shouldBeVisible(null /* starting */));
assertFalse(assistantRootTask.shouldBeVisible(null /* starting */));
}
}
private Task createStandardRootTaskForVisibilityTest(int windowingMode,
boolean translucent) {
final Task rootTask = createTaskForShouldBeVisibleTest(mDefaultTaskDisplayArea,

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

@@ -16,7 +16,7 @@
package com.android.server.wm;
import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_PRIMARY;
import static android.app.WindowConfiguration.WINDOWING_MODE_MULTI_WINDOW;
import static android.content.pm.ActivityInfo.RESIZE_MODE_RESIZEABLE;
import static android.content.pm.ActivityInfo.RESIZE_MODE_UNRESIZEABLE;
import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
@@ -937,8 +937,8 @@ public class SizeCompatTests extends WindowTestsBase {
mTask.reparent(organizer.mPrimary, POSITION_TOP,
false /*moveParents*/, "test");
organizer.mPrimary.setBounds(0, 0, 1000, 1400);
assertEquals(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, mTask.getWindowingMode());
assertEquals(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, activity.getWindowingMode());
assertEquals(WINDOWING_MODE_MULTI_WINDOW, mTask.getWindowingMode());
assertEquals(WINDOWING_MODE_MULTI_WINDOW, activity.getWindowingMode());
// Resizable activity is sandboxed due to config being enabled.
assertActivityMaxBoundsSandboxed(activity);
@@ -1828,8 +1828,8 @@ public class SizeCompatTests extends WindowTestsBase {
mTask.reparent(organizer.mPrimary, POSITION_TOP,
false /*moveParents*/, "test");
organizer.mPrimary.setBounds(0, 0, 1000, 1400);
assertEquals(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, mTask.getWindowingMode());
assertEquals(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, mActivity.getWindowingMode());
assertEquals(WINDOWING_MODE_MULTI_WINDOW, mTask.getWindowingMode());
assertEquals(WINDOWING_MODE_MULTI_WINDOW, mActivity.getWindowingMode());
// Non-resizable activity in size compat mode
assertScaled();
@@ -1868,8 +1868,8 @@ public class SizeCompatTests extends WindowTestsBase {
mTask.reparent(organizer.mPrimary, POSITION_TOP,
false /*moveParents*/, "test");
organizer.mPrimary.setBounds(0, 0, 1000, 1400);
assertEquals(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, mTask.getWindowingMode());
assertEquals(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, mActivity.getWindowingMode());
assertEquals(WINDOWING_MODE_MULTI_WINDOW, mTask.getWindowingMode());
assertEquals(WINDOWING_MODE_MULTI_WINDOW, mActivity.getWindowingMode());
// Non-resizable activity in size compat mode
assertScaled();

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

@@ -17,14 +17,10 @@
package com.android.server.wm;
import static android.app.AppOpsManager.OP_NONE;
import static android.app.WindowConfiguration.ACTIVITY_TYPE_HOME;
import static android.app.WindowConfiguration.ACTIVITY_TYPE_RECENTS;
import static android.app.WindowConfiguration.ACTIVITY_TYPE_STANDARD;
import static android.app.WindowConfiguration.ACTIVITY_TYPE_UNDEFINED;
import static android.app.WindowConfiguration.ROTATION_UNDEFINED;
import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_PRIMARY;
import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_SECONDARY;
import static android.app.WindowConfiguration.WINDOWING_MODE_MULTI_WINDOW;
import static android.app.WindowConfiguration.WINDOWING_MODE_UNDEFINED;
import static android.content.pm.ActivityInfo.RESIZE_MODE_RESIZEABLE;
import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED;
@@ -66,15 +62,14 @@ import static org.mockito.Mockito.mock;
import android.annotation.IntDef;
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.app.ActivityManager;
import android.app.ActivityOptions;
import android.app.IApplicationThread;
import android.app.WindowConfiguration;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.pm.ActivityInfo;
import android.content.pm.ApplicationInfo;
import android.graphics.Rect;
import android.hardware.HardwareBuffer;
import android.hardware.display.DisplayManager;
import android.os.Build;
@@ -1515,64 +1510,55 @@ class WindowTestsBase extends SystemServiceTestsBase {
static class TestSplitOrganizer extends WindowOrganizerTests.StubOrganizer {
final ActivityTaskManagerService mService;
final TaskDisplayArea mDefaultTDA;
Task mPrimary;
Task mSecondary;
boolean mInSplit = false;
// moves everything to secondary. Most tests expect this since sysui usually does it.
boolean mMoveToSecondaryOnEnter = true;
int mDisplayId;
private static final int[] CONTROLLED_ACTIVITY_TYPES = {
ACTIVITY_TYPE_STANDARD,
ACTIVITY_TYPE_HOME,
ACTIVITY_TYPE_RECENTS,
ACTIVITY_TYPE_UNDEFINED
};
private static final int[] CONTROLLED_WINDOWING_MODES = {
WINDOWING_MODE_FULLSCREEN,
WINDOWING_MODE_SPLIT_SCREEN_SECONDARY,
WINDOWING_MODE_UNDEFINED
};
TestSplitOrganizer(ActivityTaskManagerService service, DisplayContent display) {
mService = service;
mDefaultTDA = display.getDefaultTaskDisplayArea();
mDisplayId = display.mDisplayId;
mService.mTaskOrganizerController.registerTaskOrganizer(this);
mPrimary = mService.mTaskOrganizerController.createRootTask(
display, WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, null);
display, WINDOWING_MODE_MULTI_WINDOW, null);
mSecondary = mService.mTaskOrganizerController.createRootTask(
display, WINDOWING_MODE_SPLIT_SCREEN_SECONDARY, null);;
display, WINDOWING_MODE_MULTI_WINDOW, null);
mPrimary.setAdjacentTaskFragment(mSecondary, true);
display.getDefaultTaskDisplayArea().setLaunchAdjacentFlagRootTask(mSecondary);
final Rect primaryBounds = new Rect();
final Rect secondaryBounds = new Rect();
display.getBounds().splitVertically(primaryBounds, secondaryBounds);
mPrimary.setBounds(primaryBounds);
mSecondary.setBounds(secondaryBounds);
}
TestSplitOrganizer(ActivityTaskManagerService service) {
this(service, service.mTaskSupervisor.mRootWindowContainer.getDefaultDisplay());
}
public void setMoveToSecondaryOnEnter(boolean move) {
mMoveToSecondaryOnEnter = move;
public Task createTaskToPrimary(boolean onTop) {
final Task primaryTask = mDefaultTDA.createRootTask(
WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_STANDARD, onTop);
putTaskToPrimary(primaryTask, onTop);
return primaryTask;
}
@Override
public void onTaskInfoChanged(ActivityManager.RunningTaskInfo info) {
if (mInSplit) {
return;
}
if (info.topActivityType == ACTIVITY_TYPE_UNDEFINED) {
// Not populated
return;
}
if (info.configuration.windowConfiguration.getWindowingMode()
!= WINDOWING_MODE_SPLIT_SCREEN_PRIMARY) {
return;
}
mInSplit = true;
if (!mMoveToSecondaryOnEnter) {
return;
}
DisplayContent dc = mService.mRootWindowContainer.getDisplayContent(mDisplayId);
dc.getDefaultTaskDisplayArea().setLaunchRootTask(
mSecondary, CONTROLLED_WINDOWING_MODES, CONTROLLED_ACTIVITY_TYPES);
dc.forAllRootTasks(rootTask -> {
if (!WindowConfiguration.isSplitScreenWindowingMode(rootTask.getWindowingMode())) {
rootTask.reparent(mSecondary, POSITION_BOTTOM);
}
});
public Task createTaskToSecondary(boolean onTop) {
final Task secondaryTask = mDefaultTDA.createRootTask(
WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_STANDARD, onTop);
putTaskToSecondary(secondaryTask, onTop);
return secondaryTask;
}
public void putTaskToPrimary(Task task, boolean onTop) {
task.reparent(mPrimary, onTop ? POSITION_TOP : POSITION_BOTTOM);
}
public void putTaskToSecondary(Task task, boolean onTop) {
task.reparent(mSecondary, onTop ? POSITION_TOP : POSITION_BOTTOM);
}
}