From 3129b8533514b28c976b8713e017656fe6a91a54 Mon Sep 17 00:00:00 2001
From: Garfield Tan <xutan@google.com>
Date: Mon, 24 Jun 2019 16:51:20 -0700
Subject: [PATCH 1/2] Only persist launch params on freeform display.

We don't want to launch to fullscreen only because it's been launched on
a fullscreen display before. We should still restore the bounds when it
was on a freeform display last time.

Bug: 135941344
Bug: 135780225
Test: Manual tests.
Change-Id: I9f57651a01513652cc4c38c2d91d4c46db5c5d5d
---
 core/java/android/app/WindowConfiguration.java      |  5 +++++
 .../core/java/com/android/server/wm/TaskRecord.java | 13 ++++++++++---
 2 files changed, 15 insertions(+), 3 deletions(-)

diff --git a/core/java/android/app/WindowConfiguration.java b/core/java/android/app/WindowConfiguration.java
index affc8b9283fbc..c40031631a74e 100644
--- a/core/java/android/app/WindowConfiguration.java
+++ b/core/java/android/app/WindowConfiguration.java
@@ -338,6 +338,11 @@ public class WindowConfiguration implements Parcelable, Comparable<WindowConfigu
         mDisplayWindowingMode = windowingMode;
     }
 
+    /** @hide */
+    @WindowingMode
+    public int getDisplayWindowingMode() {
+        return mDisplayWindowingMode;
+    }
 
     public void setActivityType(@ActivityType int activityType) {
         if (mActivityType == activityType) {
diff --git a/services/core/java/com/android/server/wm/TaskRecord.java b/services/core/java/com/android/server/wm/TaskRecord.java
index 3fd4e83b94944..7c7fdae45a47b 100644
--- a/services/core/java/com/android/server/wm/TaskRecord.java
+++ b/services/core/java/com/android/server/wm/TaskRecord.java
@@ -1908,7 +1908,7 @@ class TaskRecord extends ConfigurationContainer {
     /**
      * Saves launching state if necessary so that we can launch the activity to its latest state.
      * It only saves state if this task has been shown to user and it's in fullscreen or freeform
-     * mode.
+     * mode on freeform displays.
      */
     void saveLaunchingStateIfNeeded() {
         if (!hasBeenVisible) {
@@ -1917,8 +1917,15 @@ class TaskRecord extends ConfigurationContainer {
         }
 
         final int windowingMode = getWindowingMode();
-        if (windowingMode != WindowConfiguration.WINDOWING_MODE_FULLSCREEN
-                && windowingMode != WindowConfiguration.WINDOWING_MODE_FREEFORM) {
+        if (windowingMode != WINDOWING_MODE_FULLSCREEN
+                && windowingMode != WINDOWING_MODE_FREEFORM) {
+            return;
+        }
+
+        // Don't persist state if display isn't in freeform mode. Then the task will be launched
+        // back to its last state in a freeform display when it's launched in a freeform display
+        // next time.
+        if (getWindowConfiguration().getDisplayWindowingMode() != WINDOWING_MODE_FREEFORM) {
             return;
         }
 

From a7a919c087d2543425c87039bde2a9d1cadae611 Mon Sep 17 00:00:00 2001
From: Garfield Tan <xutan@google.com>
Date: Tue, 25 Jun 2019 12:36:34 -0700
Subject: [PATCH 2/2] Don't set windowing mode in fullscreen displays.

We don't want to launch tasks in freeform mode in fullscreen displays
only because they were in freeform mode before.

Bug: 135941344
Bug: 135780225
Test: Manual tests.
Test: atest WmTests:TaskLaunchParamsModifierTests
Change-Id: Ifd466d1e11c8131ecf1e587aeac6f2eba15f6432
---
 .../server/wm/TaskLaunchParamsModifier.java   |  4 ++-
 .../wm/TaskLaunchParamsModifierTests.java     | 28 ++++++++++++++++++-
 2 files changed, 30 insertions(+), 2 deletions(-)

diff --git a/services/core/java/com/android/server/wm/TaskLaunchParamsModifier.java b/services/core/java/com/android/server/wm/TaskLaunchParamsModifier.java
index 14585c531203c..76dd7bef6ea64 100644
--- a/services/core/java/com/android/server/wm/TaskLaunchParamsModifier.java
+++ b/services/core/java/com/android/server/wm/TaskLaunchParamsModifier.java
@@ -211,7 +211,9 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier {
         if (!currentParams.isEmpty() && !hasInitialBounds
                 && (!currentParams.hasPreferredDisplay()
                     || displayId == currentParams.mPreferredDisplayId)) {
-            if (currentParams.hasWindowingMode()) {
+            // 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()) {
                 launchMode = currentParams.mWindowingMode;
                 fullyResolvedCurrentParam = launchMode != WINDOWING_MODE_FREEFORM;
                 if (DEBUG) {
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 f918149e67818..24ff07d4bffe8 100644
--- a/services/tests/wmtests/src/com/android/server/wm/TaskLaunchParamsModifierTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/TaskLaunchParamsModifierTests.java
@@ -345,6 +345,19 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase {
                 WINDOWING_MODE_FULLSCREEN);
     }
 
+    @Test
+    public void testLaunchesFullscreenOnFullscreenDisplayWithFreeformHistory() {
+        mCurrent.mPreferredDisplayId = Display.INVALID_DISPLAY;
+        mCurrent.mWindowingMode = WINDOWING_MODE_FREEFORM;
+        mCurrent.mBounds.set(0, 0, 200, 100);
+
+        assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null,
+                mActivity, /* source */ null, /* options */ null, mCurrent, mResult));
+
+        assertEquivalentWindowingMode(WINDOWING_MODE_FULLSCREEN, mResult.mWindowingMode,
+                WINDOWING_MODE_FULLSCREEN);
+    }
+
     @Test
     public void testRespectsFullyResolvedCurrentParam_Fullscreen() {
         final TestActivityDisplay freeformDisplay = createNewActivityDisplay(
@@ -1173,6 +1186,19 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase {
         assertEquals(new Rect(0, 0, 1680, 953), mResult.mBounds);
     }
 
+    @Test
+    public void returnsNonFullscreenBoundsOnFullscreenDisplayWithFreeformHistory() {
+        mCurrent.mPreferredDisplayId = Display.INVALID_DISPLAY;
+        mCurrent.mWindowingMode = WINDOWING_MODE_FREEFORM;
+        mCurrent.mBounds.set(0, 0, 200, 100);
+
+        assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null,
+                mActivity, /* source */ null, /* options */ null, mCurrent, mResult));
+
+        // Returned bounds with in fullscreen mode will be set to last non-fullscreen bounds.
+        assertEquals(new Rect(0, 0, 200, 100), mCurrent.mBounds);
+    }
+
     @Test
     public void testAdjustsBoundsToFitInDisplayFullyResolvedBounds() {
         final TestActivityDisplay freeformDisplay = createNewActivityDisplay(
@@ -1186,7 +1212,7 @@ public class TaskLaunchParamsModifierTests extends ActivityTestsBase {
         options.setLaunchDisplayId(freeformDisplay.mDisplayId);
 
         assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null,
-                mActivity, /* source */ null, /* options */ null, mCurrent, mResult));
+                mActivity, /* source */ null, options, mCurrent, mResult));
 
         assertEquals(new Rect(0, 0, 300, 300), mResult.mBounds);
     }