Merge "Home tasks inherit split or fullscreen from parent." into rvc-dev am:... (4eeb4d44) · Commits · e / os / android_frameworks_base

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

+31 −21

Original line number	Diff line number	Diff line
		@@ -2225,14 +2225,16 @@ class Task extends WindowContainer<WindowContainer> {
		}
		density *= DisplayMetrics.DENSITY_DEFAULT_SCALE;

		// If bounds have been overridden at this level, restrict config resources to these bounds
		// rather than the parent because the overridden bounds can be larger than the parent.
		boolean hasOverrideBounds = false;

		final Rect resolvedBounds = inOutConfig.windowConfiguration.getBounds();
		if (resolvedBounds == null) {
		mTmpFullBounds.setEmpty();
		if (resolvedBounds == null \|\| resolvedBounds.isEmpty()) {
		mTmpFullBounds.set(parentConfig.windowConfiguration.getBounds());
		} else {
		mTmpFullBounds.set(resolvedBounds);
		}
		if (mTmpFullBounds.isEmpty()) {
		mTmpFullBounds.set(parentConfig.windowConfiguration.getBounds());
		hasOverrideBounds = true;
		}

		Rect outAppBounds = inOutConfig.windowConfiguration.getAppBounds();
		@@ -2244,7 +2246,16 @@ class Task extends WindowContainer<WindowContainer> {
		// the out bounds doesn't need to be restricted by the parent.
		final boolean insideParentBounds = compatInsets == null;
		if (insideParentBounds && windowingMode != WINDOWING_MODE_FREEFORM) {
		final Rect parentAppBounds = parentConfig.windowConfiguration.getAppBounds();
		Rect parentAppBounds;
		if (hasOverrideBounds) {
		// Since we overrode the bounds, restrict appBounds to display non-decor rather
		// than parent. Otherwise, it won't match the overridden bounds.
		final TaskDisplayArea displayArea = getDisplayArea();
		parentAppBounds = displayArea != null
		? displayArea.getConfiguration().windowConfiguration.getAppBounds() : null;
		} else {
		parentAppBounds = parentConfig.windowConfiguration.getAppBounds();
		}
		if (parentAppBounds != null && !parentAppBounds.isEmpty()) {
		outAppBounds.intersect(parentAppBounds);
		}
		@@ -2291,13 +2302,13 @@ class Task extends WindowContainer<WindowContainer> {

		if (inOutConfig.screenWidthDp == Configuration.SCREEN_WIDTH_DP_UNDEFINED) {
		final int overrideScreenWidthDp = (int) (mTmpStableBounds.width() / density);
		inOutConfig.screenWidthDp = insideParentBounds
		inOutConfig.screenWidthDp = (insideParentBounds && !hasOverrideBounds)
		? Math.min(overrideScreenWidthDp, parentConfig.screenWidthDp)
		: overrideScreenWidthDp;
		}
		if (inOutConfig.screenHeightDp == Configuration.SCREEN_HEIGHT_DP_UNDEFINED) {
		final int overrideScreenHeightDp = (int) (mTmpStableBounds.height() / density);
		inOutConfig.screenHeightDp = insideParentBounds
		inOutConfig.screenHeightDp = (insideParentBounds && !hasOverrideBounds)
		? Math.min(overrideScreenHeightDp, parentConfig.screenHeightDp)
		: overrideScreenHeightDp;
		}
		@@ -2344,27 +2355,27 @@ class Task extends WindowContainer<WindowContainer> {
		mTmpBounds.set(getResolvedOverrideConfiguration().windowConfiguration.getBounds());
		super.resolveOverrideConfiguration(newParentConfig);

		// Resolve override windowing mode to fullscreen for home task (even on freeform
		// display), or split-screen-secondary if in split-screen mode.
		int windowingMode =
		getResolvedOverrideConfiguration().windowConfiguration.getWindowingMode();

		// Resolve override windowing mode to fullscreen for home task (even on freeform
		// display), or split-screen if in split-screen mode.
		if (getActivityType() == ACTIVITY_TYPE_HOME && windowingMode == WINDOWING_MODE_UNDEFINED) {
		final int parentWindowingMode = newParentConfig.windowConfiguration.getWindowingMode();
		windowingMode = parentWindowingMode == WINDOWING_MODE_SPLIT_SCREEN_SECONDARY
		? WINDOWING_MODE_SPLIT_SCREEN_SECONDARY
		: WINDOWING_MODE_FULLSCREEN;
		windowingMode = WindowConfiguration.isSplitScreenWindowingMode(parentWindowingMode)
		? parentWindowingMode : WINDOWING_MODE_FULLSCREEN;
		getResolvedOverrideConfiguration().windowConfiguration.setWindowingMode(windowingMode);
		}

		if (!isLeafTask()) {
		// Compute configuration overrides for tasks that created by organizer, so that
		// organizer can get the correct configuration from those tasks.
		if (mCreatedByOrganizer) {
		computeConfigResourceOverrides(getResolvedOverrideConfiguration(), newParentConfig);
		if (isLeafTask()) {
		resolveLeafOnlyOverrideConfigs(newParentConfig);
		}
		return;
		computeConfigResourceOverrides(getResolvedOverrideConfiguration(), newParentConfig);
		}

		void resolveLeafOnlyOverrideConfigs(Configuration newParentConfig) {
		int windowingMode =
		getResolvedOverrideConfiguration().windowConfiguration.getWindowingMode();
		if (windowingMode == WINDOWING_MODE_UNDEFINED) {
		windowingMode = newParentConfig.windowConfiguration.getWindowingMode();
		}
		@@ -2404,7 +2415,6 @@ class Task extends WindowContainer<WindowContainer> {
		outOverrideBounds.offset(0, offsetTop);
		}
		}
		computeConfigResourceOverrides(getResolvedOverrideConfiguration(), newParentConfig);
		}

		/**

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

+9 −1

Original line number	Diff line number	Diff line
		@@ -329,6 +329,7 @@ class ActivityTestsBase extends SystemServiceTestsBase {
		private boolean mCreateStack = true;

		private ActivityStack mStack;
		private TaskDisplayArea mTaskDisplayArea;

		TaskBuilder(ActivityStackSupervisor supervisor) {
		mSupervisor = supervisor;
		@@ -378,9 +379,16 @@ class ActivityTestsBase extends SystemServiceTestsBase {
		return this;
		}

		TaskBuilder setDisplay(DisplayContent display) {
		mTaskDisplayArea = display.getDefaultTaskDisplayArea();
		return this;
		}

		Task build() {
		if (mStack == null && mCreateStack) {
		mStack = mSupervisor.mRootWindowContainer.getDefaultTaskDisplayArea().createStack(
		TaskDisplayArea displayArea = mTaskDisplayArea != null ? mTaskDisplayArea
		: mSupervisor.mRootWindowContainer.getDefaultTaskDisplayArea();
		mStack = displayArea.createStack(
		WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */);
		spyOn(mStack);
		}

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

+34 −24

Original line number	Diff line number	Diff line
		@@ -54,10 +54,7 @@ import static org.junit.Assert.assertNull;
		import static org.junit.Assert.assertThat;
		import static org.junit.Assert.assertTrue;
		import static org.mockito.ArgumentMatchers.any;
		import static org.mockito.ArgumentMatchers.anyInt;
		import static org.mockito.ArgumentMatchers.same;
		import static org.mockito.Mockito.mock;
		import static org.mockito.Mockito.verify;

		import android.app.ActivityManager;
		import android.app.TaskInfo;
		@@ -75,12 +72,10 @@ import android.util.DisplayMetrics;
		import android.util.Xml;
		import android.view.DisplayInfo;

		import androidx.test.filters.FlakyTest;
		import androidx.test.filters.MediumTest;

		import com.android.internal.app.IVoiceInteractor;
		import com.android.server.wm.Task.TaskFactory;
		import com.android.server.wm.utils.WmDisplayCutout;

		import org.junit.Before;
		import org.junit.Test;
		@@ -368,25 +363,38 @@ public class TaskRecordTests extends ActivityTestsBase {

		@Test
		public void testComputeConfigResourceOverrides() {
		final Task task = new TaskBuilder(mSupervisor).build();
		final Rect fullScreenBounds = new Rect(0, 0, 1080, 1920);
		TestDisplayContent display = new TestDisplayContent.Builder(
		mService, fullScreenBounds.width(), fullScreenBounds.height()).build();
		final Task task = new TaskBuilder(mSupervisor).setDisplay(display).build();
		final Configuration inOutConfig = new Configuration();
		final Configuration parentConfig = new Configuration();
		final int longSide = 1200;
		final int shortSide = 600;
		final Rect parentBounds = new Rect(0, 0, 250, 500);
		parentConfig.windowConfiguration.setBounds(parentBounds);
		parentConfig.densityDpi = 400;
		parentConfig.screenHeightDp = 200; // 200 * 400 / 160 = 500px
		parentConfig.screenWidthDp = 100; // 100 * 400 / 160 = 250px
		parentConfig.screenHeightDp = (parentBounds.bottom * 160) / parentConfig.densityDpi; // 200
		parentConfig.screenWidthDp = (parentBounds.right * 160) / parentConfig.densityDpi; // 100
		parentConfig.windowConfiguration.setRotation(ROTATION_0);

		// Portrait bounds.
		inOutConfig.windowConfiguration.getBounds().set(0, 0, shortSide, longSide);
		// By default, the parent bounds should limit the existing input bounds.
		// By default, the input bounds will fill parent.
		task.computeConfigResourceOverrides(inOutConfig, parentConfig);

		assertEquals(parentConfig.screenHeightDp, inOutConfig.screenHeightDp);
		assertEquals(parentConfig.screenWidthDp, inOutConfig.screenWidthDp);
		assertEquals(Configuration.ORIENTATION_PORTRAIT, inOutConfig.orientation);

		// If bounds are overridden, config properties should be made to match. Surface hierarchy
		// will crop for policy.
		inOutConfig.setToDefaults();
		inOutConfig.windowConfiguration.getBounds().set(0, 0, shortSide, longSide);
		// By default, the parent bounds should limit the existing input bounds.
		task.computeConfigResourceOverrides(inOutConfig, parentConfig);

		assertEquals(longSide, inOutConfig.screenHeightDp * parentConfig.densityDpi / 160);
		assertEquals(shortSide, inOutConfig.screenWidthDp * parentConfig.densityDpi / 160);

		inOutConfig.setToDefaults();
		// Landscape bounds.
		inOutConfig.windowConfiguration.getBounds().set(0, 0, longSide, shortSide);
		@@ -394,21 +402,17 @@ public class TaskRecordTests extends ActivityTestsBase {
		// Setup the display with a top stable inset. The later assertion will ensure the inset is
		// excluded from screenHeightDp.
		final int statusBarHeight = 100;
		final DisplayContent displayContent = task.mDisplayContent;
		final DisplayPolicy policy = mock(DisplayPolicy.class);
		final DisplayPolicy policy = display.getDisplayPolicy();
		doAnswer(invocationOnMock -> {
		final Rect insets = invocationOnMock.<Rect>getArgument(0);
		insets.top = statusBarHeight;
		return null;
		}).when(policy).convertNonDecorInsetsToStableInsets(any(), eq(ROTATION_0));
		doReturn(policy).when(displayContent).getDisplayPolicy();
		doReturn(mock(WmDisplayCutout.class)).when(displayContent)
		.calculateDisplayCutoutForRotation(anyInt());

		// Without limiting to be inside the parent bounds, the out screen size should keep relative
		// to the input bounds.
		final ActivityRecord.CompatDisplayInsets compatIntsets =
		new ActivityRecord.CompatDisplayInsets(displayContent, task);
		new ActivityRecord.CompatDisplayInsets(display, task);
		task.computeConfigResourceOverrides(inOutConfig, parentConfig, compatIntsets);

		assertEquals((shortSide - statusBarHeight) * DENSITY_DEFAULT / parentConfig.densityDpi,
		@@ -454,7 +458,6 @@ public class TaskRecordTests extends ActivityTestsBase {
		parentConfig.screenWidthDp = 100; // 100 * 400 / 160 = 250px
		parentConfig.windowConfiguration.setRotation(ROTATION_0);

		final float density = 2.5f; // densityDpi / DENSITY_DEFAULT_SCALE = 400 / 160.0f
		final int longSideDp = 480; // longSide / density = 1200 / 400 * 160
		final int shortSideDp = 240; // shortSide / density = 600 / 400 * 160
		final int screenLayout = parentConfig.screenLayout
		@@ -463,31 +466,38 @@ public class TaskRecordTests extends ActivityTestsBase {
		Configuration.reduceScreenLayout(screenLayout, longSideDp, shortSideDp);

		// Portrait bounds overlapping with navigation bar, without insets.
		inOutConfig.windowConfiguration.getBounds().set(0,
		final Rect freeformBounds = new Rect(0,
		displayHeight - 10 - longSide,
		shortSide,
		displayHeight - 10);
		inOutConfig.windowConfiguration.setBounds(freeformBounds);
		// Set to freeform mode to verify bug fix.
		inOutConfig.windowConfiguration.setWindowingMode(WINDOWING_MODE_FREEFORM);

		task.computeConfigResourceOverrides(inOutConfig, parentConfig);

		assertEquals(parentConfig.screenWidthDp, inOutConfig.screenWidthDp);
		assertEquals(parentConfig.screenHeightDp, inOutConfig.screenHeightDp);
		// screenW/H should not be effected by parent since overridden and freeform
		assertEquals(freeformBounds.width() * 160 / parentConfig.densityDpi,
		inOutConfig.screenWidthDp);
		assertEquals(freeformBounds.height() * 160 / parentConfig.densityDpi,
		inOutConfig.screenHeightDp);
		assertEquals(reducedScreenLayout, inOutConfig.screenLayout);

		inOutConfig.setToDefaults();
		// Landscape bounds overlapping with navigtion bar, without insets.
		inOutConfig.windowConfiguration.getBounds().set(0,
		freeformBounds.set(0,
		displayHeight - 10 - shortSide,
		longSide,
		displayHeight - 10);
		inOutConfig.windowConfiguration.setBounds(freeformBounds);
		inOutConfig.windowConfiguration.setWindowingMode(WINDOWING_MODE_FREEFORM);

		task.computeConfigResourceOverrides(inOutConfig, parentConfig);

		assertEquals(parentConfig.screenWidthDp, inOutConfig.screenWidthDp);
		assertEquals(parentConfig.screenHeightDp, inOutConfig.screenHeightDp);
		assertEquals(freeformBounds.width() * 160 / parentConfig.densityDpi,
		inOutConfig.screenWidthDp);
		assertEquals(freeformBounds.height() * 160 / parentConfig.densityDpi,
		inOutConfig.screenHeightDp);
		assertEquals(reducedScreenLayout, inOutConfig.screenLayout);
		}

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

+3 −6

Original line number	Diff line number	Diff line
		@@ -44,7 +44,6 @@ import static com.android.server.wm.WindowContainer.POSITION_TOP;

		import static org.junit.Assert.assertEquals;
		import static org.junit.Assert.assertFalse;
		import static org.junit.Assert.assertNotEquals;
		import static org.junit.Assert.assertNotNull;
		import static org.junit.Assert.assertTrue;
		import static org.mockito.ArgumentMatchers.any;
		@@ -407,22 +406,20 @@ public class WindowOrganizerTests extends WindowTestsBase {
		.setWindowingMode(WINDOWING_MODE_FREEFORM).build();
		final Task task = stack.getTopMostTask();
		WindowContainerTransaction t = new WindowContainerTransaction();
		t.setBounds(task.mRemoteToken.toWindowContainerToken(), new Rect(10, 10, 100, 100));
		mWm.mAtmService.mWindowOrganizerController.applyTransaction(t);
		final int origScreenWDp = task.getConfiguration().screenHeightDp;
		final int origScreenHDp = task.getConfiguration().screenHeightDp;
		t = new WindowContainerTransaction();
		// verify that setting config overrides on parent restricts children.
		t.setScreenSizeDp(stack.mRemoteToken
		.toWindowContainerToken(), origScreenWDp, origScreenHDp);
		t.setBounds(task.mRemoteToken.toWindowContainerToken(), new Rect(10, 10, 150, 200));
		.toWindowContainerToken(), origScreenWDp, origScreenHDp / 2);
		mWm.mAtmService.mWindowOrganizerController.applyTransaction(t);
		assertEquals(origScreenHDp, task.getConfiguration().screenHeightDp);
		assertEquals(origScreenHDp / 2, task.getConfiguration().screenHeightDp);
		t = new WindowContainerTransaction();
		t.setScreenSizeDp(stack.mRemoteToken.toWindowContainerToken(), SCREEN_WIDTH_DP_UNDEFINED,
		SCREEN_HEIGHT_DP_UNDEFINED);
		mWm.mAtmService.mWindowOrganizerController.applyTransaction(t);
		assertNotEquals(origScreenHDp, task.getConfiguration().screenHeightDp);
		assertEquals(origScreenHDp, task.getConfiguration().screenHeightDp);
		}

		@Test