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

Determine whether to support activities in multi window (3/n)

Browse Source 
Add flags to support device settings for support activities in multi
window.

Will use the new flag to determine whether an activity can be shown in
multi window.

Bug: 176061101
Test: atest WmTests:ActivityTaskManagerServiceTests
Change-Id: I2808b0bbf2ce436f972a0239ece7d6a781af035b
This commit is contained in:
Chris Li
2021-04-28 17:59:31 -07:00
parent f9c4ee1fd3
commit 02e4c2deda
15 changed files with 372 additions and 37 deletions
Download Patch File Download Diff File Expand all files Collapse all files

35
core/res/res/values/config.xml
View File

@@ -3517,6 +3517,41 @@
<!-- True if the device supports split screen as a form of multi-window. -->
<bool name="config_supportsSplitScreenMultiWindow">true</bool>
<!-- Whether the device supports non-resizable activity 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 config_largeScreenSmallestScreenWidthDp}).
1: The device always supports non-resizable in multi windowing modes.
-->
<integer name="config_supportsNonResizableMultiWindow">0</integer>
<!-- Whether the device checks the activity min width/height to determine if it can be shown in
multi windowing modes.
-1: The device ignores the activity min width/height when determining if it can be shown in
multi windowing modes.
0: If this is a small screen (smallest width <
{@link config_largeScreenSmallestScreenWidthDp}), the device compares the activity min
width/height with the min multi windowing modes dimensions the device supports to
determine if 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 config_minPercentageMultiWindowSupportWidth} the device
supports to determine if the activity can be shown in multi windowing modes.
-->
<integer name="config_respectsActivityMinWidthHeightMultiWindow">0</integer>
<!-- 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].
-->
<item name="config_minPercentageMultiWindowSupportWidth" format="float" type="dimen">0.3</item>
<!-- If the display smallest screen width 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.
-->
<integer name="config_largeScreenSmallestScreenWidthDp">600</integer>
<!-- True if the device supports running activities on secondary displays. -->
<bool name="config_supportsMultiDisplay">true</bool>

4
core/res/res/values/symbols.xml
View File

@@ -392,6 +392,10 @@
<java-symbol type="bool" name="config_supportsMultiWindow" />
<java-symbol type="bool" name="config_supportsSplitScreenMultiWindow" />
<java-symbol type="bool" name="config_supportsMultiDisplay" />
<java-symbol type="integer" name="config_supportsNonResizableMultiWindow" />
<java-symbol type="integer" name="config_respectsActivityMinWidthHeightMultiWindow" />
<java-symbol type="dimen" name="config_minPercentageMultiWindowSupportWidth" />
<java-symbol type="integer" name="config_largeScreenSmallestScreenWidthDp" />
<java-symbol type="bool" name="config_noHomeScreen" />
<java-symbol type="bool" name="config_supportsSystemDecorsOnSecondaryDisplays" />
<java-symbol type="bool" name="config_supportsInsecureLockScreen" />

23
services/core/java/com/android/server/wm/ActivityRecord.java
View File

@@ -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);
}
/**

59
services/core/java/com/android/server/wm/ActivityTaskManagerService.java
View File

@@ -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<ActivityTaskManagerInternal.ScreenObserver> 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

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

@@ -1994,7 +1994,25 @@ class Task extends WindowContainer<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);
}
/**

56
services/core/java/com/android/server/wm/TaskDisplayArea.java
View File

@@ -1660,6 +1660,62 @@ final class TaskDisplayArea extends DisplayArea<WindowContainer> {
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();
}

14
services/core/java/com/android/server/wm/WindowManagerService.java
View File

@@ -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() {

12
services/tests/wmtests/src/com/android/server/wm/ActivityRecordTests.java
View File

@@ -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());
}

131
services/tests/wmtests/src/com/android/server/wm/ActivityTaskManagerServiceTests.java
View File

@@ -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());
}
}

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

@@ -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());

5
services/tests/wmtests/src/com/android/server/wm/SystemServicesTestRule.java
View File

@@ -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

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

@@ -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();

2
services/tests/wmtests/src/com/android/server/wm/WindowManagerSettingsTests.java
View File

@@ -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);
}
}

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

@@ -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());

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

@@ -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) {