Merge "Refactor TestSplitOrganizer and remove useless code" (d6b531e6) · Commits · e / os / android_frameworks_base

services/core/java/com/android/server/wm/Task.java

+1 −19

Original line number	Diff line number	Diff line
		@@ -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 */);

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

+7 −50

Original line number	Diff line number	Diff line
		@@ -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);

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

+24 −121

Original line number	Diff line number	Diff line
		@@ -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,

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

+7 −7

Original line number	Diff line number	Diff line
		@@ -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();

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

+36 −50

File changed.

Preview size limit exceeded, changes collapsed.