Merge "Revert "Let WM shell set launch display area per params"" (2c468f1b) · Commits · e / os / android_frameworks_base

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

+2 −8

Original line number	Diff line number	Diff line
		@@ -277,8 +277,7 @@ class LaunchParamsController {
		@interface Phase {}

		/**
		* Stops once we are done with preferred display calculation. The result returned from this
		* phase is only guaranteed to have a display area which display is the launch display.
		* Stops once we are done with preferred display calculation.
		*/
		int PHASE_DISPLAY = 0;

		@@ -287,15 +286,10 @@ class LaunchParamsController {
		*/
		int PHASE_WINDOWING_MODE = 1;

		/**
		* Stops once we are done with display area calculation.
		*/
		int PHASE_DISPLAY_AREA = 2;

		/**
		* Stops once we are done with window bounds calculation.
		*/
		int PHASE_BOUNDS = 3;
		int PHASE_BOUNDS = 2;

		/**
		* Returns the launch params that the provided activity launch params should be overridden

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

+11 −48

Original line number	Diff line number	Diff line
		@@ -89,8 +89,6 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier {
		private final Rect mTmpStableBounds = new Rect();
		private final int[] mTmpDirections = new int[2];

		private TaskDisplayArea mTmpDisplayArea;

		private StringBuilder mLogBuilder;

		TaskLaunchParamsModifier(ActivityTaskSupervisor supervisor) {
		@@ -129,15 +127,15 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier {
		return RESULT_SKIP;
		}

		// STEP 1: Determine the suggested display area to launch the activity/task.
		final TaskDisplayArea suggestedDisplayArea = getPreferredLaunchTaskDisplayArea(task,
		// STEP 1: Determine the display area to launch the activity/task.
		final TaskDisplayArea taskDisplayArea = getPreferredLaunchTaskDisplayArea(task,
		options, source, currentParams, activity, request);
		outParams.mPreferredTaskDisplayArea = suggestedDisplayArea;
		final DisplayContent display = suggestedDisplayArea.mDisplayContent;
		outParams.mPreferredTaskDisplayArea = taskDisplayArea;
		// TODO(b/152116619): Update the usages of display to use taskDisplayArea below.
		final DisplayContent display = taskDisplayArea.mDisplayContent;
		if (DEBUG) {
		appendLog("display-id=" + display.getDisplayId()
		+ " display-windowing-mode=" + display.getWindowingMode()
		+ " suggested-display-area=" + suggestedDisplayArea);
		appendLog("task-display-area=" + outParams.mPreferredTaskDisplayArea
		+ " display-area-windowing-mode=" + taskDisplayArea.getWindowingMode());
		}

		if (phase == PHASE_DISPLAY) {
		@@ -206,11 +204,9 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier {
		// We inherit launch params from previous modifiers or LaunchParamsController if options,
		// layout and display conditions are not contradictory to their suggestions. It's important
		// to carry over their values because LaunchParamsController doesn't automatically do that.
		// We only check if display matches because display area can be changed later.
		if (!currentParams.isEmpty() && !hasInitialBounds
		&& (currentParams.mPreferredTaskDisplayArea == null
		\|\| currentParams.mPreferredTaskDisplayArea.getDisplayId()
		== display.getDisplayId())) {
		\|\| currentParams.mPreferredTaskDisplayArea == taskDisplayArea)) {
		// Only set windowing mode if display is in freeform. If the display is in fullscreen
		// mode we should only launch a task in fullscreen mode.
		if (currentParams.hasWindowingMode() && display.inFreeformWindowingMode()) {
		@@ -259,47 +255,14 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier {
		return RESULT_CONTINUE;
		}

		// STEP 3: Finalize the display area. Here we allow WM shell route all launches that match
		// certain criteria to specific task display areas.
		final int resolvedMode = (launchMode != WINDOWING_MODE_UNDEFINED) ? launchMode
		: display.getWindowingMode();
		TaskDisplayArea taskDisplayArea = suggestedDisplayArea;
		// If launch task display area is set in options we should just use it. We assume the
		// suggestedDisplayArea has the right one in this case.
		if (options == null \|\| options.getLaunchTaskDisplayArea() == null) {
		final int activityType =
		mSupervisor.mRootWindowContainer.resolveActivityType(root, options, task);
		display.forAllTaskDisplayAreas(displayArea -> {
		final Task launchRoot = displayArea.getLaunchRootTask(resolvedMode, activityType);
		if (launchRoot == null) {
		return false;
		}
		mTmpDisplayArea = displayArea;
		return true;
		});
		if (mTmpDisplayArea != null) {
		taskDisplayArea = mTmpDisplayArea;
		mTmpDisplayArea = null;
		appendLog("overridden-display-area=["
		+ WindowConfiguration.activityTypeToString(activityType) + ", "
		+ WindowConfiguration.windowingModeToString(resolvedMode) + ", "
		+ taskDisplayArea + "]");
		}
		}
		appendLog("display-area=" + taskDisplayArea);
		outParams.mPreferredTaskDisplayArea = taskDisplayArea;

		if (phase == PHASE_DISPLAY_AREA) {
		return RESULT_CONTINUE;
		}
		// TODO(b/152116619): Update the usages of display to use taskDisplayArea below.

		// STEP 4: Determine final launch bounds based on resolved windowing mode and activity
		// STEP 3: Determine final launch bounds based on resolved windowing mode and activity
		// requested orientation. We set bounds to empty for fullscreen mode and keep bounds as is
		// for all other windowing modes that's not freeform mode. One can read comments in
		// relevant methods to further understand this step.
		//
		// We skip making adjustments if the params are fully resolved from previous results.
		final int resolvedMode = (launchMode != WINDOWING_MODE_UNDEFINED) ? launchMode
		: display.getWindowingMode();
		if (fullyResolvedCurrentParam) {
		if (resolvedMode == WINDOWING_MODE_FREEFORM) {
		// Make sure bounds are in the display if it's possibly in a different display/area.

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

+13 −89

Original line number	Diff line number	Diff line
		@@ -16,7 +16,6 @@

		package com.android.server.wm;

		import static android.app.WindowConfiguration.ACTIVITY_TYPE_HOME;
		import static android.app.WindowConfiguration.ACTIVITY_TYPE_STANDARD;
		import static android.app.WindowConfiguration.WINDOWING_MODE_FREEFORM;
		import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
		@@ -33,7 +32,6 @@ import static android.view.InsetsState.ITYPE_CLIMATE_BAR;
		import static android.view.InsetsState.ITYPE_EXTRA_NAVIGATION_BAR;
		import static android.view.InsetsState.ITYPE_NAVIGATION_BAR;
		import static android.view.InsetsState.ITYPE_STATUS_BAR;
		import static android.window.DisplayAreaOrganizer.FEATURE_RUNTIME_TASK_CONTAINER_FIRST;

		import static com.android.dx.mockito.inline.extended.ExtendedMockito.doNothing;
		import static com.android.dx.mockito.inline.extended.ExtendedMockito.spyOn;
		@@ -115,9 +113,9 @@ public class TaskLaunchParamsModifierTests extends WindowTestsBase {
		assertEquals(RESULT_SKIP, new CalculateRequestBuilder().setActivity(null).calculate());
		}

		// =======================
		// Display Related Tests
		// =======================
		// =============================
		// Display ID Related Tests
		// =============================
		@Test
		public void testDefaultToPrimaryDisplayArea() {
		createNewDisplayContent(WINDOWING_MODE_FREEFORM);
		@@ -293,7 +291,7 @@ public class TaskLaunchParamsModifierTests extends WindowTestsBase {
		when(mActivity.getProcessName()).thenReturn(processName);
		when(mActivity.getUid()).thenReturn(uid);
		doReturn(controller)
		.when(mAtm)
		.when(mSupervisor.mService)
		.getProcessController(processName, uid);

		assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().calculate());
		@@ -314,11 +312,11 @@ public class TaskLaunchParamsModifierTests extends WindowTestsBase {
		when(mActivity.getProcessName()).thenReturn(processName);
		when(mActivity.getUid()).thenReturn(uid);
		doReturn(null)
		.when(mAtm)
		.when(mSupervisor.mService)
		.getProcessController(processName, uid);

		doReturn(controller)
		.when(mAtm)
		.when(mSupervisor.mService)
		.getProcessController(mActivity.launchedFromPid, mActivity.launchedFromUid);

		assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().calculate());
		@@ -346,10 +344,10 @@ public class TaskLaunchParamsModifierTests extends WindowTestsBase {
		.thenReturn(expectedTaskDisplayArea);

		doReturn(controllerForApplication)
		.when(mAtm)
		.when(mSupervisor.mService)
		.getProcessController(processName, uid);
		doReturn(controllerForLaunching)
		.when(mAtm)
		.when(mSupervisor.mService)
		.getProcessController(mActivity.launchedFromPid, mActivity.launchedFromUid);

		assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().calculate());
		@@ -371,15 +369,15 @@ public class TaskLaunchParamsModifierTests extends WindowTestsBase {
		when(controller.getTopActivityDisplayArea()).thenReturn(expectedTaskDisplayArea);

		doReturn(null)
		.when(mAtm)
		.when(mSupervisor.mService)
		.getProcessController(mActivity.processName, mActivity.info.applicationInfo.uid);

		doReturn(null)
		.when(mAtm)
		.when(mSupervisor.mService)
		.getProcessController(mActivity.launchedFromPid, mActivity.launchedFromUid);

		doReturn(controller)
		.when(mAtm)
		.when(mSupervisor.mService)
		.getProcessController(request.realCallingPid, request.realCallingUid);

		assertEquals(RESULT_CONTINUE,
		@@ -391,11 +389,11 @@ public class TaskLaunchParamsModifierTests extends WindowTestsBase {
		@Test
		public void testUsesDefaultDisplayAreaIfWindowProcessControllerIsNotPresent() {
		doReturn(null)
		.when(mAtm)
		.when(mSupervisor.mService)
		.getProcessController(mActivity.processName, mActivity.info.applicationInfo.uid);

		doReturn(null)
		.when(mAtm)
		.when(mSupervisor.mService)
		.getProcessController(mActivity.launchedFromPid, mActivity.launchedFromUid);

		assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().calculate());
		@@ -403,80 +401,6 @@ public class TaskLaunchParamsModifierTests extends WindowTestsBase {
		assertEquals(DEFAULT_DISPLAY, mResult.mPreferredTaskDisplayArea.getDisplayId());
		}

		@Test
		public void testOverridesDisplayAreaWithStandardTypeAndFullscreenMode() {
		final TaskDisplayArea secondaryDisplayArea = createTaskDisplayArea(mDefaultDisplay,
		mWm, "SecondaryDisplayArea", FEATURE_RUNTIME_TASK_CONTAINER_FIRST);
		final Task launchRoot = createTaskStackOnTaskDisplayArea(WINDOWING_MODE_FULLSCREEN,
		ACTIVITY_TYPE_STANDARD, secondaryDisplayArea);
		launchRoot.mCreatedByOrganizer = true;

		secondaryDisplayArea.setLaunchRootTask(launchRoot, new int[] { WINDOWING_MODE_FULLSCREEN },
		new int[] { ACTIVITY_TYPE_STANDARD });

		assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().calculate());

		assertEquals(secondaryDisplayArea, mResult.mPreferredTaskDisplayArea);
		}

		@Test
		public void testOverridesDisplayAreaWithHomeTypeAndFullscreenMode() {
		final TaskDisplayArea secondaryDisplayArea = createTaskDisplayArea(mDefaultDisplay,
		mWm, "SecondaryDisplayArea", FEATURE_RUNTIME_TASK_CONTAINER_FIRST);
		final Task launchRoot = createTaskStackOnTaskDisplayArea(WINDOWING_MODE_FULLSCREEN,
		ACTIVITY_TYPE_STANDARD, secondaryDisplayArea);
		launchRoot.mCreatedByOrganizer = true;

		mActivity.setActivityType(ACTIVITY_TYPE_HOME);
		secondaryDisplayArea.setLaunchRootTask(launchRoot, new int[] { WINDOWING_MODE_FULLSCREEN },
		new int[] { ACTIVITY_TYPE_HOME });

		assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().calculate());

		assertEquals(secondaryDisplayArea, mResult.mPreferredTaskDisplayArea);
		}

		@Test
		public void testOverridesDisplayAreaWithStandardTypeAndFreeformMode() {
		final TestDisplayContent freeformDisplay = createNewDisplayContent(
		WINDOWING_MODE_FREEFORM);
		final TaskDisplayArea secondaryDisplayArea = createTaskDisplayArea(freeformDisplay,
		mWm, "SecondaryDisplayArea", FEATURE_RUNTIME_TASK_CONTAINER_FIRST);
		final Task launchRoot = createTaskStackOnTaskDisplayArea(WINDOWING_MODE_FULLSCREEN,
		ACTIVITY_TYPE_STANDARD, secondaryDisplayArea);
		launchRoot.mCreatedByOrganizer = true;

		secondaryDisplayArea.setLaunchRootTask(launchRoot, new int[] { WINDOWING_MODE_FREEFORM },
		new int[] { ACTIVITY_TYPE_STANDARD });

		mCurrent.mPreferredTaskDisplayArea = freeformDisplay.getDefaultTaskDisplayArea();
		assertEquals(RESULT_CONTINUE, new CalculateRequestBuilder().calculate());

		assertEquals(secondaryDisplayArea, mResult.mPreferredTaskDisplayArea);
		}

		@Test
		public void testNotOverrideDisplayAreaWhenActivityOptionsHasDisplayArea() {
		final TaskDisplayArea secondaryDisplayArea = createTaskDisplayArea(mDefaultDisplay,
		mWm, "SecondaryDisplayArea", FEATURE_RUNTIME_TASK_CONTAINER_FIRST);
		final Task launchRoot = createTaskStackOnTaskDisplayArea(WINDOWING_MODE_FULLSCREEN,
		ACTIVITY_TYPE_STANDARD, secondaryDisplayArea);
		launchRoot.mCreatedByOrganizer = true;

		secondaryDisplayArea.setLaunchRootTask(launchRoot, new int[] { WINDOWING_MODE_FULLSCREEN },
		new int[] { ACTIVITY_TYPE_STANDARD });

		ActivityOptions options = ActivityOptions.makeBasic();
		options.setLaunchTaskDisplayArea(
		mDefaultDisplay.getDefaultTaskDisplayArea().mRemoteToken.toWindowContainerToken());

		assertEquals(RESULT_CONTINUE,
		new CalculateRequestBuilder().setOptions(options).calculate());

		assertEquals(
		mDefaultDisplay.getDefaultTaskDisplayArea(), mResult.mPreferredTaskDisplayArea);
		}

		// =====================================
		// Launch Windowing Mode Related Tests
		// =====================================