diff --git a/core/res/res/values/config.xml b/core/res/res/values/config.xml index d3ea52eb8888b..5ebfae518eade 100644 --- a/core/res/res/values/config.xml +++ b/core/res/res/values/config.xml @@ -3517,6 +3517,41 @@ true + + 0 + + + 0 + + + 0.3 + + + 600 + true diff --git a/core/res/res/values/symbols.xml b/core/res/res/values/symbols.xml index b9f1e203552a4..3fec918f7ac05 100644 --- a/core/res/res/values/symbols.xml +++ b/core/res/res/values/symbols.xml @@ -392,6 +392,10 @@ + + + + diff --git a/services/core/java/com/android/server/wm/ActivityRecord.java b/services/core/java/com/android/server/wm/ActivityRecord.java index 6957aa0154e13..6a1b1069f57ca 100644 --- a/services/core/java/com/android/server/wm/ActivityRecord.java +++ b/services/core/java/com/android/server/wm/ActivityRecord.java @@ -2508,7 +2508,28 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A */ boolean supportsMultiWindow() { return mAtmService.mSupportsMultiWindow && !isActivityTypeHome() - && (isResizeable() || mAtmService.mSupportsNonResizableMultiWindow); + && (isResizeable() || mAtmService.mDevEnableNonResizableMultiWindow); + } + + // TODO(b/176061101) replace supportsMultiWindow() after fixing tests. + boolean supportsMultiWindow2() { + if (!mAtmService.mSupportsMultiWindow) { + return false; + } + final TaskDisplayArea tda = getDisplayArea(); + if (tda == null) { + return false; + } + + if (!isResizeable() && !tda.supportsNonResizableMultiWindow()) { + // Not support non-resizable in multi window. + return false; + } + + final ActivityInfo.WindowLayout windowLayout = info.windowLayout; + return windowLayout == null + || tda.supportsActivityMinWidthHeightMultiWindow(windowLayout.minWidth, + windowLayout.minHeight); } /** diff --git a/services/core/java/com/android/server/wm/ActivityTaskManagerService.java b/services/core/java/com/android/server/wm/ActivityTaskManagerService.java index 61985730c49f4..e249e674a174b 100644 --- a/services/core/java/com/android/server/wm/ActivityTaskManagerService.java +++ b/services/core/java/com/android/server/wm/ActivityTaskManagerService.java @@ -555,7 +555,50 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { boolean mSupportsPictureInPicture; boolean mSupportsMultiDisplay; boolean mForceResizableActivities; - volatile boolean mSupportsNonResizableMultiWindow; + + /** Development option to enable non resizable in multi window. */ + // TODO(b/176061101) change the default value to false. + boolean mDevEnableNonResizableMultiWindow; + + /** + * Whether the device supports non-resizable in multi windowing modes. + * -1: The device doesn't support non-resizable in multi windowing modes. + * 0: The device supports non-resizable in multi windowing modes only if this is a large + * screen (smallest width >= {@link #mLargeScreenSmallestScreenWidthDp}). + * 1: The device always supports non-resizable in multi windowing modes. + */ + int mSupportsNonResizableMultiWindow; + + /** + * Whether the device checks activity min width/height to determine if it can be shown in multi + * windowing modes. + * -1: The device ignores activity min width/height when determining if it can be shown in multi + * windowing modes. + * 0: If it is a small screen (smallest width < {@link #mLargeScreenSmallestScreenWidthDp}), + * the device compares the activity min width/height with the min multi windowing modes + * dimensions {@link #mMinPercentageMultiWindowSupportWidth} the device supports to + * determine whether the activity can be shown in multi windowing modes + * 1: The device always compare the activity min width/height with the min multi windowing + * modes dimensions {@link #mMinPercentageMultiWindowSupportWidth} the device supports to + * determine whether it can be shown in multi windowing modes. + */ + int mRespectsActivityMinWidthHeightMultiWindow; + + /** + * This value is only used when the device checks activity min width/height to determine if it + * can be shown in multi windowing modes. + * If the activity min width/height is greater than this percentage of the display smallest + * width, it will not be allowed to be shown in multi windowing modes. + * The value should be between [0 - 1]. + */ + float mMinPercentageMultiWindowSupportWidth; + + /** + * If the display {@link Configuration#smallestScreenWidthDp} is greater or equal to this value, + * we will treat it as a large screen device, which will have some multi window features enabled + * by default. + */ + int mLargeScreenSmallestScreenWidthDp; final List mScreenObservers = new ArrayList<>(); @@ -787,8 +830,16 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { final boolean forceRtl = Settings.Global.getInt(resolver, DEVELOPMENT_FORCE_RTL, 0) != 0; final boolean forceResizable = Settings.Global.getInt( resolver, DEVELOPMENT_FORCE_RESIZABLE_ACTIVITIES, 0) != 0; - final boolean supportsNonResizableMultiWindow = Settings.Global.getInt( + final boolean devEnableNonResizableMultiWindow = Settings.Global.getInt( resolver, DEVELOPMENT_ENABLE_NON_RESIZABLE_MULTI_WINDOW, 1) != 0; + final int supportsNonResizableMultiWindow = mContext.getResources().getInteger( + com.android.internal.R.integer.config_supportsNonResizableMultiWindow); + final int respectsActivityMinWidthHeightMultiWindow = mContext.getResources().getInteger( + com.android.internal.R.integer.config_respectsActivityMinWidthHeightMultiWindow); + final float minPercentageMultiWindowSupportWidth = mContext.getResources().getFloat( + com.android.internal.R.dimen.config_minPercentageMultiWindowSupportWidth); + final int largeScreenSmallestScreenWidthDp = mContext.getResources().getInteger( + com.android.internal.R.integer.config_largeScreenSmallestScreenWidthDp); // Transfer any global setting for forcing RTL layout, into a System Property DisplayProperties.debug_force_rtl(forceRtl); @@ -802,7 +853,11 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { synchronized (mGlobalLock) { mForceResizableActivities = forceResizable; + mDevEnableNonResizableMultiWindow = devEnableNonResizableMultiWindow; mSupportsNonResizableMultiWindow = supportsNonResizableMultiWindow; + mRespectsActivityMinWidthHeightMultiWindow = respectsActivityMinWidthHeightMultiWindow; + mMinPercentageMultiWindowSupportWidth = minPercentageMultiWindowSupportWidth; + mLargeScreenSmallestScreenWidthDp = largeScreenSmallestScreenWidthDp; final boolean multiWindowFormEnabled = freeformWindowManagement || supportsSplitScreenMultiWindow || supportsPictureInPicture diff --git a/services/core/java/com/android/server/wm/Task.java b/services/core/java/com/android/server/wm/Task.java index c6478ee968fc6..7c95edd24718a 100644 --- a/services/core/java/com/android/server/wm/Task.java +++ b/services/core/java/com/android/server/wm/Task.java @@ -1994,7 +1994,25 @@ class Task extends WindowContainer { boolean supportsMultiWindow() { return mAtmService.mSupportsMultiWindow - && (isResizeable() || mAtmService.mSupportsNonResizableMultiWindow); + && (isResizeable() || mAtmService.mDevEnableNonResizableMultiWindow); + } + + // TODO(b/176061101) replace supportsMultiWindow() after fixing tests. + boolean supportsMultiWindow2() { + if (!mAtmService.mSupportsMultiWindow) { + return false; + } + final TaskDisplayArea tda = getDisplayArea(); + if (tda == null) { + return false; + } + + if (!isResizeable() && !tda.supportsNonResizableMultiWindow()) { + // Not support non-resizable in multi window. + return false; + } + + return tda.supportsActivityMinWidthHeightMultiWindow(mMinWidth, mMinHeight); } /** diff --git a/services/core/java/com/android/server/wm/TaskDisplayArea.java b/services/core/java/com/android/server/wm/TaskDisplayArea.java index 87f685e95fe13..368e6dd610e8c 100644 --- a/services/core/java/com/android/server/wm/TaskDisplayArea.java +++ b/services/core/java/com/android/server/wm/TaskDisplayArea.java @@ -1660,6 +1660,62 @@ final class TaskDisplayArea extends DisplayArea { return windowingMode; } + /** + * Whether we can show non-resizable activities in multi window below this + * {@link TaskDisplayArea} + */ + boolean supportsNonResizableMultiWindow() { + final int configSupportsNonResizableMultiWindow = + mAtmService.mSupportsNonResizableMultiWindow; + if (mAtmService.mDevEnableNonResizableMultiWindow + || configSupportsNonResizableMultiWindow == 1) { + // Device override to support. + return true; + } + if (configSupportsNonResizableMultiWindow == -1) { + // Device override to not support. + return false; + } + // Support on large screen. + return isLargeEnoughForMultiWindow(); + } + + /** + * Whether we can show activity requesting the given min width/height in multi window below + * this {@link TaskDisplayArea}. + */ + boolean supportsActivityMinWidthHeightMultiWindow(int minWidth, int minHeight) { + final int configRespectsActivityMinWidthHeightMultiWindow = + mAtmService.mRespectsActivityMinWidthHeightMultiWindow; + if (minWidth <= 0 && minHeight <= 0) { + // No request min width/height. + return true; + } + if (configRespectsActivityMinWidthHeightMultiWindow == -1) { + // Device override to ignore min width/height. + return true; + } + if (configRespectsActivityMinWidthHeightMultiWindow == 0 + && isLargeEnoughForMultiWindow()) { + // Ignore min width/height on large screen. + return true; + } + // Check if the request min width/height is supported in multi window. + final int maxSupportMinDimensions = (int) (mAtmService.mMinPercentageMultiWindowSupportWidth + * getConfiguration().smallestScreenWidthDp + * mDisplayContent.getDisplayMetrics().density); + return minWidth <= maxSupportMinDimensions && minHeight <= maxSupportMinDimensions; + } + + /** + * Whether this is large enough to support non-resizable, and activities with min width/height + * in multi window. + */ + private boolean isLargeEnoughForMultiWindow() { + return getConfiguration().smallestScreenWidthDp + >= mAtmService.mLargeScreenSmallestScreenWidthDp; + } + boolean isTopRootTask(Task rootTask) { return rootTask == getTopRootTask(); } diff --git a/services/core/java/com/android/server/wm/WindowManagerService.java b/services/core/java/com/android/server/wm/WindowManagerService.java index 9e8b6a34e1d52..23bebf3a3015f 100644 --- a/services/core/java/com/android/server/wm/WindowManagerService.java +++ b/services/core/java/com/android/server/wm/WindowManagerService.java @@ -777,7 +777,7 @@ public class WindowManagerService extends IWindowManager.Stub Settings.Global.DEVELOPMENT_ENABLE_FREEFORM_WINDOWS_SUPPORT); private final Uri mForceResizableUri = Settings.Global.getUriFor( DEVELOPMENT_FORCE_RESIZABLE_ACTIVITIES); - private final Uri mSupportsNonResizableMultiWindowUri = Settings.Global.getUriFor( + private final Uri mDevEnableNonResizableMultiWindowUri = Settings.Global.getUriFor( DEVELOPMENT_ENABLE_NON_RESIZABLE_MULTI_WINDOW); private final Uri mRenderShadowsInCompositorUri = Settings.Global.getUriFor( DEVELOPMENT_RENDER_SHADOWS_IN_COMPOSITOR); @@ -803,7 +803,7 @@ public class WindowManagerService extends IWindowManager.Stub UserHandle.USER_ALL); resolver.registerContentObserver(mFreeformWindowUri, false, this, UserHandle.USER_ALL); resolver.registerContentObserver(mForceResizableUri, false, this, UserHandle.USER_ALL); - resolver.registerContentObserver(mSupportsNonResizableMultiWindowUri, false, this, + resolver.registerContentObserver(mDevEnableNonResizableMultiWindowUri, false, this, UserHandle.USER_ALL); resolver.registerContentObserver(mRenderShadowsInCompositorUri, false, this, UserHandle.USER_ALL); @@ -842,8 +842,8 @@ public class WindowManagerService extends IWindowManager.Stub return; } - if (mSupportsNonResizableMultiWindowUri.equals(uri)) { - updateSupportsNonResizableMultiWindow(); + if (mDevEnableNonResizableMultiWindowUri.equals(uri)) { + updateDevEnableNonResizableMultiWindow(); return; } @@ -939,12 +939,12 @@ public class WindowManagerService extends IWindowManager.Stub mAtmService.mForceResizableActivities = forceResizable; } - void updateSupportsNonResizableMultiWindow() { + void updateDevEnableNonResizableMultiWindow() { ContentResolver resolver = mContext.getContentResolver(); - final boolean supportsNonResizableMultiWindow = Settings.Global.getInt(resolver, + final boolean devEnableNonResizableMultiWindow = Settings.Global.getInt(resolver, DEVELOPMENT_ENABLE_NON_RESIZABLE_MULTI_WINDOW, 1) != 0; - mAtmService.mSupportsNonResizableMultiWindow = supportsNonResizableMultiWindow; + mAtmService.mDevEnableNonResizableMultiWindow = devEnableNonResizableMultiWindow; } void updateDisplaySettingsLocation() { diff --git a/services/tests/wmtests/src/com/android/server/wm/ActivityRecordTests.java b/services/tests/wmtests/src/com/android/server/wm/ActivityRecordTests.java index bd143f8a5c35a..fdeb7a6eb71a8 100644 --- a/services/tests/wmtests/src/com/android/server/wm/ActivityRecordTests.java +++ b/services/tests/wmtests/src/com/android/server/wm/ActivityRecordTests.java @@ -2009,17 +2009,17 @@ public class ActivityRecordTests extends WindowTestsBase { // Non-resizable mAtm.mForceResizableActivities = false; - mAtm.mSupportsNonResizableMultiWindow = false; + mAtm.mDevEnableNonResizableMultiWindow = false; assertFalse(activity.supportsSplitScreenWindowingMode()); // Force resizable mAtm.mForceResizableActivities = true; - mAtm.mSupportsNonResizableMultiWindow = false; + mAtm.mDevEnableNonResizableMultiWindow = false; assertTrue(activity.supportsSplitScreenWindowingMode()); // Allow non-resizable mAtm.mForceResizableActivities = false; - mAtm.mSupportsNonResizableMultiWindow = true; + mAtm.mDevEnableNonResizableMultiWindow = true; assertTrue(activity.supportsSplitScreenWindowingMode()); } @@ -2033,17 +2033,17 @@ public class ActivityRecordTests extends WindowTestsBase { // Non-resizable mAtm.mForceResizableActivities = false; - mAtm.mSupportsNonResizableMultiWindow = false; + mAtm.mDevEnableNonResizableMultiWindow = false; assertFalse(activity.supportsFreeform()); // Force resizable mAtm.mForceResizableActivities = true; - mAtm.mSupportsNonResizableMultiWindow = false; + mAtm.mDevEnableNonResizableMultiWindow = false; assertTrue(activity.supportsFreeform()); // Allow non-resizable mAtm.mForceResizableActivities = false; - mAtm.mSupportsNonResizableMultiWindow = true; + mAtm.mDevEnableNonResizableMultiWindow = true; assertTrue(activity.supportsFreeform()); } diff --git a/services/tests/wmtests/src/com/android/server/wm/ActivityTaskManagerServiceTests.java b/services/tests/wmtests/src/com/android/server/wm/ActivityTaskManagerServiceTests.java index 285d887a42962..618de21bb1584 100644 --- a/services/tests/wmtests/src/com/android/server/wm/ActivityTaskManagerServiceTests.java +++ b/services/tests/wmtests/src/com/android/server/wm/ActivityTaskManagerServiceTests.java @@ -16,6 +16,9 @@ package com.android.server.wm; +import static android.content.pm.ActivityInfo.RESIZE_MODE_RESIZEABLE; +import static android.content.pm.ActivityInfo.RESIZE_MODE_UNRESIZEABLE; + import static com.android.dx.mockito.inline.extended.ExtendedMockito.any; import static com.android.dx.mockito.inline.extended.ExtendedMockito.doReturn; import static com.android.dx.mockito.inline.extended.ExtendedMockito.mock; @@ -37,6 +40,7 @@ import android.app.ActivityManager; import android.app.PictureInPictureParams; import android.app.servertransaction.ClientTransaction; import android.app.servertransaction.EnterPipRequestedItem; +import android.content.pm.ActivityInfo; import android.content.res.Configuration; import android.graphics.Rect; import android.os.IBinder; @@ -307,5 +311,132 @@ public class ActivityTaskManagerServiceTests extends WindowTestsBase { assertTopNonSleeping.accept(homeActivity); } + + @Test + public void testSupportsMultiWindow_resizable() { + final ActivityRecord activity = new ActivityBuilder(mAtm) + .setCreateTask(true) + .setResizeMode(RESIZE_MODE_RESIZEABLE) + .build(); + final Task task = activity.getTask(); + + assertTrue(activity.supportsMultiWindow2()); + assertTrue(task.supportsMultiWindow2()); + } + + @Test + public void testSupportsMultiWindow_nonResizable() { + final ActivityRecord activity = new ActivityBuilder(mAtm) + .setCreateTask(true) + .setResizeMode(RESIZE_MODE_UNRESIZEABLE) + .build(); + final Task task = activity.getTask(); + final TaskDisplayArea tda = task.getDisplayArea(); + + // Device config as not support. + mAtm.mSupportsNonResizableMultiWindow = -1; + + assertFalse(activity.supportsMultiWindow2()); + assertFalse(task.supportsMultiWindow2()); + + // Device config as always support. + mAtm.mSupportsNonResizableMultiWindow = 1; + + assertTrue(activity.supportsMultiWindow2()); + assertTrue(task.supportsMultiWindow2()); + + // The default config is relying on the screen size. + mAtm.mSupportsNonResizableMultiWindow = 0; + + // Supports on large screen. + tda.getConfiguration().smallestScreenWidthDp = mAtm.mLargeScreenSmallestScreenWidthDp; + + assertTrue(activity.supportsMultiWindow2()); + assertTrue(task.supportsMultiWindow2()); + + // Not supports on small screen. + tda.getConfiguration().smallestScreenWidthDp = mAtm.mLargeScreenSmallestScreenWidthDp - 1; + + assertFalse(activity.supportsMultiWindow2()); + assertFalse(task.supportsMultiWindow2()); + } + + @Test + public void testSupportsMultiWindow_activityMinWidthHeight_largerThanSupport() { + final float density = mContext.getResources().getDisplayMetrics().density; + final ActivityInfo.WindowLayout windowLayout = + new ActivityInfo.WindowLayout(0, 0, 0, 0, 0, + // This is larger than the min dimensions device support in multi window, + // the activity will not be supported in multi window if the device respects + /* minWidth= */(int) (mAtm.mLargeScreenSmallestScreenWidthDp * density), + /* minHeight= */(int) (mAtm.mLargeScreenSmallestScreenWidthDp * density)); + final ActivityRecord activity = new ActivityBuilder(mAtm) + .setCreateTask(true) + .setWindowLayout(windowLayout) + .setResizeMode(RESIZE_MODE_RESIZEABLE) + .build(); + final Task task = activity.getTask(); + final TaskDisplayArea tda = task.getDisplayArea(); + + // Ignore the activity min width/height for determine multi window eligibility. + mAtm.mRespectsActivityMinWidthHeightMultiWindow = -1; + + assertTrue(activity.supportsMultiWindow2()); + assertTrue(task.supportsMultiWindow2()); + + // Always check the activity min width/height. + mAtm.mRespectsActivityMinWidthHeightMultiWindow = 1; + + assertFalse(activity.supportsMultiWindow2()); + assertFalse(task.supportsMultiWindow2()); + + // The default config is relying on the screen size. + mAtm.mRespectsActivityMinWidthHeightMultiWindow = 0; + + // Ignore on large screen. + tda.getConfiguration().smallestScreenWidthDp = mAtm.mLargeScreenSmallestScreenWidthDp; + + assertTrue(activity.supportsMultiWindow2()); + assertTrue(task.supportsMultiWindow2()); + + // Check on small screen. + tda.getConfiguration().smallestScreenWidthDp = mAtm.mLargeScreenSmallestScreenWidthDp - 1; + + assertFalse(activity.supportsMultiWindow2()); + assertFalse(task.supportsMultiWindow2()); + } + + @Test + public void testSupportsMultiWindow_activityMinWidthHeight_smallerThanSupport() { + // This is smaller than the min dimensions device support in multi window, + // the activity will be supported in multi window + final float density = mContext.getResources().getDisplayMetrics().density; + final int supportedDimensions = (int) ((mAtm.mLargeScreenSmallestScreenWidthDp - 1) + * mAtm.mMinPercentageMultiWindowSupportWidth * density); + final ActivityInfo.WindowLayout windowLayout = + new ActivityInfo.WindowLayout(0, 0, 0, 0, 0, + /* minWidth= */supportedDimensions, + /* minHeight= */supportedDimensions); + final ActivityRecord activity = new ActivityBuilder(mAtm) + .setCreateTask(true) + .setWindowLayout(windowLayout) + .setResizeMode(RESIZE_MODE_RESIZEABLE) + .build(); + final Task task = activity.getTask(); + final TaskDisplayArea tda = task.getDisplayArea(); + tda.getConfiguration().smallestScreenWidthDp = mAtm.mLargeScreenSmallestScreenWidthDp - 1; + + // Always check the activity min width/height. + mAtm.mSupportsNonResizableMultiWindow = 1; + + assertTrue(activity.supportsMultiWindow2()); + assertTrue(task.supportsMultiWindow2()); + + // The default config is relying on the screen size. Check for small screen + mAtm.mSupportsNonResizableMultiWindow = 0; + + assertTrue(activity.supportsMultiWindow2()); + assertTrue(task.supportsMultiWindow2()); + } } diff --git a/services/tests/wmtests/src/com/android/server/wm/SizeCompatTests.java b/services/tests/wmtests/src/com/android/server/wm/SizeCompatTests.java index 221c8b97238d4..0925e12224bef 100644 --- a/services/tests/wmtests/src/com/android/server/wm/SizeCompatTests.java +++ b/services/tests/wmtests/src/com/android/server/wm/SizeCompatTests.java @@ -1552,7 +1552,7 @@ public class SizeCompatTests extends WindowTestsBase { @Test public void testSupportsNonResizableInSplitScreen_letterboxForDifferentOrientation() { // Support non resizable in multi window - mAtm.mSupportsNonResizableMultiWindow = true; + mAtm.mDevEnableNonResizableMultiWindow = true; setUpDisplaySizeWithApp(1000, 2800); final TestSplitOrganizer organizer = new TestSplitOrganizer(mAtm, mActivity.getDisplayContent()); @@ -1607,7 +1607,7 @@ public class SizeCompatTests extends WindowTestsBase { @Test public void testSupportsNonResizableInSplitScreen_fillTaskForSameOrientation() { // Support non resizable in multi window - mAtm.mSupportsNonResizableMultiWindow = true; + mAtm.mDevEnableNonResizableMultiWindow = true; setUpDisplaySizeWithApp(1000, 2800); final TestSplitOrganizer organizer = new TestSplitOrganizer(mAtm, mActivity.getDisplayContent()); diff --git a/services/tests/wmtests/src/com/android/server/wm/SystemServicesTestRule.java b/services/tests/wmtests/src/com/android/server/wm/SystemServicesTestRule.java index 491fe98660c00..61b700253d6b0 100644 --- a/services/tests/wmtests/src/com/android/server/wm/SystemServicesTestRule.java +++ b/services/tests/wmtests/src/com/android/server/wm/SystemServicesTestRule.java @@ -483,6 +483,11 @@ public class SystemServicesTestRule implements TestRule { mSupportsSplitScreenMultiWindow = true; mSupportsFreeformWindowManagement = true; mSupportsPictureInPicture = true; + mDevEnableNonResizableMultiWindow = false; + mMinPercentageMultiWindowSupportWidth = 0.3f; + mLargeScreenSmallestScreenWidthDp = 600; + mSupportsNonResizableMultiWindow = 0; + mRespectsActivityMinWidthHeightMultiWindow = 0; doReturn(mock(IPackageManager.class)).when(this).getPackageManager(); // allow background activity starts by default diff --git a/services/tests/wmtests/src/com/android/server/wm/TaskLaunchParamsModifierTests.java b/services/tests/wmtests/src/com/android/server/wm/TaskLaunchParamsModifierTests.java index de4c40df1c798..7b0643e5ef944 100644 --- a/services/tests/wmtests/src/com/android/server/wm/TaskLaunchParamsModifierTests.java +++ b/services/tests/wmtests/src/com/android/server/wm/TaskLaunchParamsModifierTests.java @@ -504,7 +504,7 @@ public class TaskLaunchParamsModifierTests extends WindowTestsBase { @Test public void testRecalculateFreeformInitialBoundsWithOverrideDisplayArea_unresizableApp() { - mAtm.mSupportsNonResizableMultiWindow = true; + mAtm.mDevEnableNonResizableMultiWindow = true; final TestDisplayContent freeformDisplay = createNewDisplayContent( WINDOWING_MODE_FREEFORM); @@ -730,7 +730,7 @@ public class TaskLaunchParamsModifierTests extends WindowTestsBase { @Test public void testForceMaximizesUnresizeableApp() { - mAtm.mSupportsNonResizableMultiWindow = false; + mAtm.mDevEnableNonResizableMultiWindow = false; final TestDisplayContent freeformDisplay = createNewDisplayContent( WINDOWING_MODE_FREEFORM); @@ -753,7 +753,7 @@ public class TaskLaunchParamsModifierTests extends WindowTestsBase { @Test public void testLaunchesPortraitSizeCompatOnFreeformLandscapeDisplayWithFreeformSizeCompat() { - mAtm.mSupportsNonResizableMultiWindow = true; + mAtm.mDevEnableNonResizableMultiWindow = true; final TestDisplayContent freeformDisplay = createNewDisplayContent( WINDOWING_MODE_FREEFORM); @@ -781,7 +781,7 @@ public class TaskLaunchParamsModifierTests extends WindowTestsBase { @Test public void testLaunchesLandscapeSizeCompatOnFreeformLandscapeDisplayWithFreeformSizeCompat() { - mAtm.mSupportsNonResizableMultiWindow = true; + mAtm.mDevEnableNonResizableMultiWindow = true; final TestDisplayContent freeformDisplay = createNewDisplayContent( WINDOWING_MODE_FREEFORM); final ActivityOptions options = ActivityOptions.makeBasic(); @@ -797,7 +797,7 @@ public class TaskLaunchParamsModifierTests extends WindowTestsBase { @Test public void testLaunchesPortraitUnresizableOnFreeformDisplayWithFreeformSizeCompat() { - mAtm.mSupportsNonResizableMultiWindow = true; + mAtm.mDevEnableNonResizableMultiWindow = true; final TestDisplayContent freeformDisplay = createNewDisplayContent( WINDOWING_MODE_FREEFORM); final ActivityOptions options = ActivityOptions.makeBasic(); diff --git a/services/tests/wmtests/src/com/android/server/wm/WindowManagerSettingsTests.java b/services/tests/wmtests/src/com/android/server/wm/WindowManagerSettingsTests.java index 18c8cf5dfa05b..b7e5fea6ad41c 100644 --- a/services/tests/wmtests/src/com/android/server/wm/WindowManagerSettingsTests.java +++ b/services/tests/wmtests/src/com/android/server/wm/WindowManagerSettingsTests.java @@ -127,7 +127,7 @@ public class WindowManagerSettingsTests extends WindowTestsBase { .setSetting(supportsNonResizableMultiWindow); mWm.mSettingsObserver.onChange(false, supportsNonResizableMultiWindowUri); - assertEquals(mWm.mAtmService.mSupportsNonResizableMultiWindow, + assertEquals(mWm.mAtmService.mDevEnableNonResizableMultiWindow, supportsNonResizableMultiWindow); } } diff --git a/services/tests/wmtests/src/com/android/server/wm/WindowOrganizerTests.java b/services/tests/wmtests/src/com/android/server/wm/WindowOrganizerTests.java index 83f41e3e2910c..8c87befef4f9e 100644 --- a/services/tests/wmtests/src/com/android/server/wm/WindowOrganizerTests.java +++ b/services/tests/wmtests/src/com/android/server/wm/WindowOrganizerTests.java @@ -1193,13 +1193,13 @@ public class WindowOrganizerTests extends WindowTestsBase { splitPrimaryRootTask.mRemoteToken.toWindowContainerToken(), true /* onTop */); // Can't reparent non-resizable to split screen - mAtm.mSupportsNonResizableMultiWindow = false; + mAtm.mDevEnableNonResizableMultiWindow = false; mAtm.mWindowOrganizerController.applyTransaction(wct); assertEquals(rootTask, activity.getRootTask()); // Allow reparent non-resizable to split screen - mAtm.mSupportsNonResizableMultiWindow = true; + mAtm.mDevEnableNonResizableMultiWindow = true; mAtm.mWindowOrganizerController.applyTransaction(wct); assertEquals(splitPrimaryRootTask, activity.getRootTask()); diff --git a/services/tests/wmtests/src/com/android/server/wm/WindowTestsBase.java b/services/tests/wmtests/src/com/android/server/wm/WindowTestsBase.java index 9b5d352136a0f..8e0ccbee82dcf 100644 --- a/services/tests/wmtests/src/com/android/server/wm/WindowTestsBase.java +++ b/services/tests/wmtests/src/com/android/server/wm/WindowTestsBase.java @@ -804,6 +804,7 @@ class WindowTestsBase extends SystemServiceTestsBase { private WindowProcessController mWpc; private Bundle mIntentExtras; private boolean mOnTop = false; + private ActivityInfo.WindowLayout mWindowLayout; ActivityBuilder(ActivityTaskManagerService service) { mService = service; @@ -924,6 +925,11 @@ class WindowTestsBase extends SystemServiceTestsBase { return this; } + ActivityBuilder setWindowLayout(ActivityInfo.WindowLayout windowLayout) { + mWindowLayout = windowLayout; + return this; + } + ActivityRecord build() { SystemServicesTestRule.checkHoldsLock(mService.mGlobalLock); try { @@ -941,16 +947,6 @@ class WindowTestsBase extends SystemServiceTestsBase { DEFAULT_COMPONENT_CLASS_NAME + id); } - if (mCreateTask) { - mTask = new TaskBuilder(mService.mTaskSupervisor) - .setComponent(mComponent) - .setParentTask(mParentTask).build(); - } else if (mTask == null && mParentTask != null && DisplayContent.alwaysCreateRootTask( - mParentTask.getWindowingMode(), mParentTask.getActivityType())) { - // The parent task can be the task root. - mTask = mParentTask; - } - Intent intent = new Intent(); intent.setComponent(mComponent); if (mIntentExtras != null) { @@ -976,6 +972,20 @@ class WindowTestsBase extends SystemServiceTestsBase { aInfo.screenOrientation = mScreenOrientation; aInfo.configChanges |= mConfigChanges; aInfo.taskAffinity = mAffinity; + aInfo.windowLayout = mWindowLayout; + + if (mCreateTask) { + mTask = new TaskBuilder(mService.mTaskSupervisor) + .setComponent(mComponent) + // Apply the root activity info and intent + .setActivityInfo(aInfo) + .setIntent(intent) + .setParentTask(mParentTask).build(); + } else if (mTask == null && mParentTask != null && DisplayContent.alwaysCreateRootTask( + mParentTask.getWindowingMode(), mParentTask.getActivityType())) { + // The parent task can be the task root. + mTask = mParentTask; + } ActivityOptions options = null; if (mLaunchTaskBehind) {