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

Set windowing mode in TDA instead of DisplayContent

Browse Source 
Set the windowing mode in TaskDisplayArea. Earlier found that because
the windowing mode is set in DisplayContent, all WindowContainres under
the DisplayContent will inherit the new windowing mode. However, for
system windows, their windowing mode should always been fullscreen.
Setting the windowing mode in TDA can fix the issue. Using this new
method instead of resolving the system window windowing modes in
WindowToken.

Bug: b/241168290
Test: services/tests/wmtests
Change-Id: I3876020cf06f6bfe6d88431bc3609c7a67c833fc
This commit is contained in:
HQ Liu
2022-09-06 16:53:40 -07:00
parent 8df0cf455b
commit 587497bc85
13 changed files with 80 additions and 78 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
services/core/java/com/android/server/wm/DisplayContent.java
View File

@@ -1148,6 +1148,7 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
mMinSizeOfResizeableTaskDp = getMinimalTaskSizeDp();
if (DEBUG_DISPLAY) Slog.v(TAG_WM, "Creating display=" + display);
setWindowingMode(WINDOWING_MODE_FULLSCREEN);
mWmService.mDisplayWindowSettings.applySettingsToDisplayLocked(this);
}
@@ -2669,16 +2670,6 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
}
}
@Override
public void setWindowingMode(int windowingMode) {
// Intentionally call onRequestedOverrideConfigurationChanged() directly to change windowing
// mode and display windowing mode atomically.
mTmpConfiguration.setTo(getRequestedOverrideConfiguration());
mTmpConfiguration.windowConfiguration.setWindowingMode(windowingMode);
mTmpConfiguration.windowConfiguration.setDisplayWindowingMode(windowingMode);
onRequestedOverrideConfigurationChanged(mTmpConfiguration);
}
@Override
void setDisplayWindowingMode(int windowingMode) {
setWindowingMode(windowingMode);

16
services/core/java/com/android/server/wm/DisplayWindowSettings.java
View File

@@ -150,7 +150,10 @@ class DisplayWindowSettings {
final SettingsProvider.SettingsEntry overrideSettings =
mSettingsProvider.getOverrideSettings(displayInfo);
overrideSettings.mWindowingMode = mode;
dc.setWindowingMode(mode);
final TaskDisplayArea defaultTda = dc.getDefaultTaskDisplayArea();
if (defaultTda != null) {
defaultTda.setWindowingMode(mode);
}
mSettingsProvider.updateOverrideSettings(displayInfo, overrideSettings);
}
@@ -253,8 +256,10 @@ class DisplayWindowSettings {
// Setting windowing mode first, because it may override overscan values later.
final int windowingMode = getWindowingModeLocked(settings, dc);
dc.setWindowingMode(windowingMode);
final TaskDisplayArea defaultTda = dc.getDefaultTaskDisplayArea();
if (defaultTda != null) {
defaultTda.setWindowingMode(windowingMode);
}
final int userRotationMode = settings.mUserRotationMode != null
? settings.mUserRotationMode : WindowManagerPolicy.USER_ROTATION_FREE;
final int userRotation = settings.mUserRotation != null
@@ -311,10 +316,11 @@ class DisplayWindowSettings {
* changed.
*/
boolean updateSettingsForDisplay(DisplayContent dc) {
if (dc.getWindowingMode() != getWindowingModeLocked(dc)) {
final TaskDisplayArea defaultTda = dc.getDefaultTaskDisplayArea();
if (defaultTda != null && defaultTda.getWindowingMode() != getWindowingModeLocked(dc)) {
// For the time being the only thing that may change is windowing mode, so just update
// that.
dc.setWindowingMode(getWindowingModeLocked(dc));
defaultTda.setWindowingMode(getWindowingModeLocked(dc));
return true;
}
return false;

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

@@ -172,6 +172,8 @@ final class TaskDisplayArea extends DisplayArea<WindowContainer> {
*/
private final boolean mCanHostHomeTask;
private final Configuration mTempConfiguration = new Configuration();
TaskDisplayArea(DisplayContent displayContent, WindowManagerService service, String name,
int displayAreaFeature) {
this(displayContent, service, name, displayAreaFeature, false /* createdByOrganizer */,
@@ -1890,6 +1892,15 @@ final class TaskDisplayArea extends DisplayArea<WindowContainer> {
mPreferredTopFocusableRootTask = null;
}
@Override
public void setWindowingMode(int windowingMode) {
mTempConfiguration.setTo(getRequestedOverrideConfiguration());
WindowConfiguration tempRequestWindowConfiguration = mTempConfiguration.windowConfiguration;
tempRequestWindowConfiguration.setWindowingMode(windowingMode);
tempRequestWindowConfiguration.setDisplayWindowingMode(windowingMode);
onRequestedOverrideConfigurationChanged(mTempConfiguration);
}
@Override
TaskDisplayArea getTaskDisplayArea() {
return this;

43
services/core/java/com/android/server/wm/TaskLaunchParamsModifier.java
View File

@@ -137,7 +137,7 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier {
final DisplayContent display = suggestedDisplayArea.mDisplayContent;
if (DEBUG) {
appendLog("display-id=" + display.getDisplayId()
+ " display-windowing-mode=" + display.getWindowingMode()
+ " task-display-area-windowing-mode=" + suggestedDisplayArea.getWindowingMode()
+ " suggested-display-area=" + suggestedDisplayArea);
}
@@ -156,7 +156,7 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier {
// source is a freeform window in a fullscreen display launching an activity on the same
// display.
if (launchMode == WINDOWING_MODE_UNDEFINED
&& canInheritWindowingModeFromSource(display, source)) {
&& canInheritWindowingModeFromSource(display, suggestedDisplayArea, source)) {
// The source's windowing mode may be different from its task, e.g. activity is set
// to fullscreen and its task is pinned windowing mode when the activity is entering
// pip.
@@ -184,7 +184,8 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier {
// is set with the suggestedDisplayArea. If it is set, but the eventual TaskDisplayArea is
// different, we should recalculating the bounds.
boolean hasInitialBoundsForSuggestedDisplayAreaInFreeformWindow = false;
final boolean canApplyFreeformPolicy = canApplyFreeformWindowPolicy(display, launchMode);
final boolean canApplyFreeformPolicy =
canApplyFreeformWindowPolicy(suggestedDisplayArea, launchMode);
if (mSupervisor.canUseActivityOptionsLaunchBounds(options)
&& (canApplyFreeformPolicy || canApplyPipWindowPolicy(launchMode))) {
hasInitialBounds = true;
@@ -239,7 +240,8 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier {
== display.getDisplayId())) {
// 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()) {
if (currentParams.hasWindowingMode()
&& suggestedDisplayArea.inFreeformWindowingMode()) {
launchMode = currentParams.mWindowingMode;
fullyResolvedCurrentParam = launchMode != WINDOWING_MODE_FREEFORM;
if (DEBUG) {
@@ -267,11 +269,11 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier {
// this step is to define the default policy when there is no initial bounds or a fully
// resolved current params from callers.
// hasInitialBoundsForSuggestedDisplayAreaInFreeformDisplay is set if the outParams.mBounds
// hasInitialBoundsForSuggestedDisplayAreaInFreeformMode is set if the outParams.mBounds
// is set with the suggestedDisplayArea. If it is set, but the eventual TaskDisplayArea is
// different, we should recalcuating the bounds.
boolean hasInitialBoundsForSuggestedDisplayAreaInFreeformDisplay = false;
if (display.inFreeformWindowingMode()) {
boolean hasInitialBoundsForSuggestedDisplayAreaInFreeformMode = false;
if (suggestedDisplayArea.inFreeformWindowingMode()) {
if (launchMode == WINDOWING_MODE_PINNED) {
if (DEBUG) appendLog("picture-in-picture");
} else if (!root.isResizeable()) {
@@ -280,7 +282,7 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier {
if (outParams.mBounds.isEmpty()) {
getTaskBounds(root, suggestedDisplayArea, layout, launchMode,
hasInitialBounds, outParams.mBounds);
hasInitialBoundsForSuggestedDisplayAreaInFreeformDisplay = true;
hasInitialBoundsForSuggestedDisplayAreaInFreeformMode = true;
}
if (DEBUG) appendLog("unresizable-freeform");
} else {
@@ -290,10 +292,10 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier {
}
}
} else {
if (DEBUG) appendLog("non-freeform-display");
if (DEBUG) appendLog("non-freeform-task-display-area");
}
// If launch mode matches display windowing mode, let it inherit from display.
outParams.mWindowingMode = launchMode == display.getWindowingMode()
outParams.mWindowingMode = launchMode == suggestedDisplayArea.getWindowingMode()
? WINDOWING_MODE_UNDEFINED : launchMode;
if (phase == PHASE_WINDOWING_MODE) {
@@ -303,7 +305,7 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier {
// 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();
: suggestedDisplayArea.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.
@@ -320,14 +322,17 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier {
mTmpDisplayArea = displayArea;
return true;
});
// We may need to recalculate the bounds if the new TaskDisplayArea is different from
// the suggested one we used to calculate the bounds.
// We may need to recalculate the bounds and the windowing mode if the new
// TaskDisplayArea is different from the suggested one we used to calculate the two
// configurations.
if (mTmpDisplayArea != null && mTmpDisplayArea != suggestedDisplayArea) {
outParams.mWindowingMode = (launchMode == mTmpDisplayArea.getWindowingMode())
? WINDOWING_MODE_UNDEFINED : launchMode;
if (hasInitialBoundsForSuggestedDisplayAreaInFreeformWindow) {
outParams.mBounds.setEmpty();
getLayoutBounds(mTmpDisplayArea, root, layout, outParams.mBounds);
hasInitialBounds = !outParams.mBounds.isEmpty();
} else if (hasInitialBoundsForSuggestedDisplayAreaInFreeformDisplay) {
} else if (hasInitialBoundsForSuggestedDisplayAreaInFreeformMode) {
outParams.mBounds.setEmpty();
getTaskBounds(root, mTmpDisplayArea, layout, launchMode,
hasInitialBounds, outParams.mBounds);
@@ -519,7 +524,7 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier {
}
private boolean canInheritWindowingModeFromSource(@NonNull DisplayContent display,
@Nullable ActivityRecord source) {
TaskDisplayArea suggestedDisplayArea, @Nullable ActivityRecord source) {
if (source == null) {
return false;
}
@@ -527,7 +532,7 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier {
// There is not really any strong reason to tie the launching windowing mode and the source
// on freeform displays. The launching windowing mode is more tied to the content of the new
// activities.
if (display.inFreeformWindowingMode()) {
if (suggestedDisplayArea.inFreeformWindowingMode()) {
return false;
}
@@ -543,9 +548,11 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier {
return display.getDisplayId() == source.getDisplayId();
}
private boolean canApplyFreeformWindowPolicy(@NonNull DisplayContent display, int launchMode) {
private boolean canApplyFreeformWindowPolicy(@NonNull TaskDisplayArea suggestedDisplayArea,
int launchMode) {
return mSupervisor.mService.mSupportsFreeformWindowManagement
&& (display.inFreeformWindowingMode() || launchMode == WINDOWING_MODE_FREEFORM);
&& (suggestedDisplayArea.inFreeformWindowingMode()
|| launchMode == WINDOWING_MODE_FREEFORM);
}
private boolean canApplyPipWindowPolicy(int launchMode) {

7
services/core/java/com/android/server/wm/WindowToken.java
View File

@@ -16,7 +16,6 @@
package com.android.server.wm;
import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
import static android.app.WindowConfiguration.WINDOWING_MODE_PINNED;
import static android.view.WindowManager.LayoutParams.TYPE_NAVIGATION_BAR;
@@ -631,12 +630,6 @@ class WindowToken extends WindowContainer<WindowState> {
getResolvedOverrideConfiguration().updateFrom(
mFixedRotationTransformState.mRotatedOverrideConfiguration);
}
if (getTaskDisplayArea() == null) {
// We only defined behaviors of system windows in fullscreen mode, i.e. windows not
// contained in a task display area.
getResolvedOverrideConfiguration().windowConfiguration.setWindowingMode(
WINDOWING_MODE_FULLSCREEN);
}
}
@Override

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

@@ -134,9 +134,9 @@ public class AppChangeTransitionTests extends WindowTestsBase {
@Test
public void testNoChangeOnOldDisplayWhenMoveDisplay() {
mDisplayContent.setWindowingMode(WINDOWING_MODE_FULLSCREEN);
mDisplayContent.getDefaultTaskDisplayArea().setWindowingMode(WINDOWING_MODE_FULLSCREEN);
final DisplayContent dc1 = createNewDisplay(Display.STATE_ON);
dc1.setWindowingMode(WINDOWING_MODE_FREEFORM);
dc1.getDefaultTaskDisplayArea().setWindowingMode(WINDOWING_MODE_FREEFORM);
setUpOnDisplay(dc1);
assertEquals(WINDOWING_MODE_FREEFORM, mTask.getWindowingMode());

19
services/tests/wmtests/src/com/android/server/wm/DisplayContentTests.java
View File

@@ -1066,6 +1066,7 @@ public class DisplayContentTests extends WindowTestsBase {
final DisplayContent dc = createNewDisplay();
dc.getDisplayRotation().setFixedToUserRotation(
IWindowManager.FIXED_TO_USER_ROTATION_DISABLED);
dc.getDefaultTaskDisplayArea().setWindowingMode(WINDOWING_MODE_FULLSCREEN);
final int newOrientation = getRotatedOrientation(dc);
final Task task = new TaskBuilder(mSupervisor)
@@ -1125,6 +1126,7 @@ public class DisplayContentTests extends WindowTestsBase {
IWindowManager.FIXED_TO_USER_ROTATION_ENABLED);
dc.getDisplayRotation().setUserRotation(
WindowManagerPolicy.USER_ROTATION_LOCKED, ROTATION_0);
dc.getDefaultTaskDisplayArea().setWindowingMode(WINDOWING_MODE_FULLSCREEN);
final int newOrientation = getRotatedOrientation(dc);
final Task task = new TaskBuilder(mSupervisor)
@@ -2027,23 +2029,6 @@ public class DisplayContentTests extends WindowTestsBase {
mDisplayContent.ensureActivitiesVisible(null, 0, false, false);
}
@Test
public void testSetWindowingModeAtomicallyUpdatesWindoingModeAndDisplayWindowingMode() {
final DisplayContent dc = createNewDisplay();
final Task rootTask = new TaskBuilder(mSupervisor)
.setDisplay(dc)
.build();
doAnswer(invocation -> {
Object[] args = invocation.getArguments();
final Configuration config = ((Configuration) args[0]);
assertEquals(config.windowConfiguration.getWindowingMode(),
config.windowConfiguration.getDisplayWindowingMode());
return null;
}).when(rootTask).onConfigurationChanged(any());
dc.setWindowingMode(WINDOWING_MODE_FREEFORM);
dc.setWindowingMode(WINDOWING_MODE_FULLSCREEN);
}
@Test
public void testForceDesktopMode() {
mWm.mForceDesktopModeOnExternalDisplays = true;

19
services/tests/wmtests/src/com/android/server/wm/DisplayWindowSettingsTests.java
View File

@@ -110,7 +110,7 @@ public class DisplayWindowSettingsTests extends WindowTestsBase {
mDisplayWindowSettings.applySettingsToDisplayLocked(mPrimaryDisplay);
assertEquals(WindowConfiguration.WINDOWING_MODE_FULLSCREEN,
mPrimaryDisplay.getWindowingMode());
mPrimaryDisplay.getDefaultTaskDisplayArea().getWindowingMode());
}
@Test
@@ -120,7 +120,7 @@ public class DisplayWindowSettingsTests extends WindowTestsBase {
mDisplayWindowSettings.applySettingsToDisplayLocked(mPrimaryDisplay);
assertEquals(WindowConfiguration.WINDOWING_MODE_FULLSCREEN,
mPrimaryDisplay.getWindowingMode());
mPrimaryDisplay.getDefaultTaskDisplayArea().getWindowingMode());
}
@Test
@@ -131,7 +131,7 @@ public class DisplayWindowSettingsTests extends WindowTestsBase {
mDisplayWindowSettings.applySettingsToDisplayLocked(mPrimaryDisplay);
assertEquals(WindowConfiguration.WINDOWING_MODE_FULLSCREEN,
mPrimaryDisplay.getWindowingMode());
mPrimaryDisplay.getDefaultTaskDisplayArea().getWindowingMode());
}
@Test
@@ -141,7 +141,8 @@ public class DisplayWindowSettingsTests extends WindowTestsBase {
mDisplayWindowSettings.applySettingsToDisplayLocked(mPrimaryDisplay);
assertEquals(WINDOWING_MODE_FREEFORM, mPrimaryDisplay.getWindowingMode());
assertEquals(WINDOWING_MODE_FREEFORM,
mPrimaryDisplay.getDefaultTaskDisplayArea().getWindowingMode());
}
@Test
@@ -154,7 +155,7 @@ public class DisplayWindowSettingsTests extends WindowTestsBase {
mDisplayWindowSettings.updateSettingsForDisplay(mPrimaryDisplay);
assertEquals(WindowConfiguration.WINDOWING_MODE_FREEFORM,
mPrimaryDisplay.getWindowingMode());
mPrimaryDisplay.getDefaultTaskDisplayArea().getWindowingMode());
}
@Test
@@ -162,7 +163,7 @@ public class DisplayWindowSettingsTests extends WindowTestsBase {
mDisplayWindowSettings.applySettingsToDisplayLocked(mSecondaryDisplay);
assertEquals(WindowConfiguration.WINDOWING_MODE_FULLSCREEN,
mSecondaryDisplay.getWindowingMode());
mSecondaryDisplay.getDefaultTaskDisplayArea().getWindowingMode());
}
@Test
@@ -172,7 +173,7 @@ public class DisplayWindowSettingsTests extends WindowTestsBase {
mDisplayWindowSettings.applySettingsToDisplayLocked(mSecondaryDisplay);
assertEquals(WindowConfiguration.WINDOWING_MODE_FULLSCREEN,
mSecondaryDisplay.getWindowingMode());
mSecondaryDisplay.getDefaultTaskDisplayArea().getWindowingMode());
}
@Test
@@ -183,7 +184,7 @@ public class DisplayWindowSettingsTests extends WindowTestsBase {
mDisplayWindowSettings.applySettingsToDisplayLocked(mSecondaryDisplay);
assertEquals(WINDOWING_MODE_FREEFORM,
mSecondaryDisplay.getWindowingMode());
mSecondaryDisplay.getDefaultTaskDisplayArea().getWindowingMode());
}
@Test
@@ -194,7 +195,7 @@ public class DisplayWindowSettingsTests extends WindowTestsBase {
mDisplayWindowSettings.applySettingsToDisplayLocked(mSecondaryDisplay);
assertEquals(WINDOWING_MODE_FREEFORM,
mSecondaryDisplay.getWindowingMode());
mSecondaryDisplay.getDefaultTaskDisplayArea().getWindowingMode());
}
@Test

8
services/tests/wmtests/src/com/android/server/wm/RootWindowContainerTests.java
View File

@@ -107,9 +107,10 @@ public class RootWindowContainerTests extends WindowTestsBase {
}
@Test
public void testUpdateDefaultDisplayWindowingModeOnSettingsRetrieved() {
public void testUpdateDefaultTaskDisplayAreaWindowingModeOnSettingsRetrieved() {
assertEquals(WindowConfiguration.WINDOWING_MODE_FULLSCREEN,
mWm.getDefaultDisplayContentLocked().getWindowingMode());
mWm.getDefaultDisplayContentLocked().getDefaultTaskDisplayArea()
.getWindowingMode());
mWm.mIsPc = true;
mWm.mAtmService.mSupportsFreeformWindowManagement = true;
@@ -117,7 +118,8 @@ public class RootWindowContainerTests extends WindowTestsBase {
mWm.mRoot.onSettingsRetrieved();
assertEquals(WindowConfiguration.WINDOWING_MODE_FREEFORM,
mWm.getDefaultDisplayContentLocked().getWindowingMode());
mWm.getDefaultDisplayContentLocked().getDefaultTaskDisplayArea()
.getWindowingMode());
}
/**

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

@@ -676,7 +676,8 @@ public class SizeCompatTests extends WindowTestsBase {
// The non-resizable activity should not be size compat because the display support
// changing windowing mode from fullscreen to freeform.
mTask.mDisplayContent.setDisplayWindowingMode(WindowConfiguration.WINDOWING_MODE_FREEFORM);
mTask.mDisplayContent.getDefaultTaskDisplayArea()
.setWindowingMode(WindowConfiguration.WINDOWING_MODE_FREEFORM);
mTask.setWindowingMode(WindowConfiguration.WINDOWING_MODE_FULLSCREEN);
assertFalse(activity.shouldCreateCompatDisplayInsets());
// Activity should not be sandboxed.

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

@@ -345,7 +345,7 @@ public class SystemServicesTestRule implements TestRule {
// Set default display to be in fullscreen mode. Devices with PC feature may start their
// default display in freeform mode but some of tests in WmTests have implicit assumption on
// that the default display is in fullscreen mode.
display.setDisplayWindowingMode(WINDOWING_MODE_FULLSCREEN);
display.getDefaultTaskDisplayArea().setWindowingMode(WINDOWING_MODE_FULLSCREEN);
spyOn(display);
final TaskDisplayArea taskDisplayArea = display.getDefaultTaskDisplayArea();

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

@@ -1775,7 +1775,7 @@ public class TaskLaunchParamsModifierTests extends WindowTestsBase {
private TestDisplayContent createNewDisplayContent(int windowingMode) {
final TestDisplayContent display = addNewDisplayContentAt(DisplayContent.POSITION_TOP);
display.setWindowingMode(windowingMode);
display.getDefaultTaskDisplayArea().setWindowingMode(windowingMode);
display.setBounds(DISPLAY_BOUNDS);
display.getConfiguration().densityDpi = DENSITY_DEFAULT;
display.getConfiguration().orientation = ORIENTATION_LANDSCAPE;

13
services/tests/wmtests/src/com/android/server/wm/TaskTests.java
View File

@@ -1256,7 +1256,8 @@ public class TaskTests extends WindowTestsBase {
final Task task = getTestTask();
task.setHasBeenVisible(false);
task.getDisplayContent().setDisplayWindowingMode(WINDOWING_MODE_FREEFORM);
task.getDisplayContent().getDefaultTaskDisplayArea()
.setWindowingMode(WINDOWING_MODE_FREEFORM);
task.getRootTask().setWindowingMode(WINDOWING_MODE_FULLSCREEN);
task.setHasBeenVisible(true);
@@ -1272,7 +1273,9 @@ public class TaskTests extends WindowTestsBase {
final Task task = getTestTask();
task.setHasBeenVisible(false);
task.getDisplayContent().setWindowingMode(WindowConfiguration.WINDOWING_MODE_FREEFORM);
task.getDisplayContent()
.getDefaultTaskDisplayArea()
.setWindowingMode(WindowConfiguration.WINDOWING_MODE_FREEFORM);
task.getRootTask().setWindowingMode(WINDOWING_MODE_FULLSCREEN);
final DisplayContent oldDisplay = task.getDisplayContent();
@@ -1312,7 +1315,8 @@ public class TaskTests extends WindowTestsBase {
final Task task = getTestTask();
task.setHasBeenVisible(false);
task.getDisplayContent().setDisplayWindowingMode(WINDOWING_MODE_FREEFORM);
task.getDisplayContent().getDefaultTaskDisplayArea()
.setWindowingMode(WINDOWING_MODE_FREEFORM);
task.getRootTask().setWindowingMode(WINDOWING_MODE_PINNED);
task.setHasBeenVisible(true);
@@ -1329,7 +1333,8 @@ public class TaskTests extends WindowTestsBase {
final Task task = new TaskBuilder(mSupervisor).setCreateActivity(true)
.setCreateParentTask(true).build().getRootTask();
task.setHasBeenVisible(false);
task.getDisplayContent().setDisplayWindowingMode(WINDOWING_MODE_FREEFORM);
task.getDisplayContent().getDefaultTaskDisplayArea()
.setWindowingMode(WINDOWING_MODE_FREEFORM);
task.getRootTask().setWindowingMode(WINDOWING_MODE_FULLSCREEN);
final Task leafTask = createTaskInRootTask(task, 0 /* userId */);