From d4957437b7eabb42c6887a63b3b38df803cb5061 Mon Sep 17 00:00:00 2001
From: Riddle Hsu <riddlehsu@google.com>
Date: Fri, 24 Apr 2020 22:06:29 +0800
Subject: [PATCH 1/3] Extensive handling of fixed rotation launching app

This fixes a case that display does not rotate after multiple
activities in a different rotation than display are launched.

- Link the transform state from the existing one to the new
  launching activity. So the heavy duplicated calculation is
  omitted and they can be recognized as a group to continue
  to update display rotation.
- Add a dedicated transition listener so it will not miss to
  handle display rotation if the reported token is different.
  That avoids leakage if somehow the transition is not notified
  then the listener is not unregistered. The path to finish
  fixed rotation is also simplified because there is always a
  transition listener to handle the incoming record.

Fixes: 154911677
Test: atest DisplayContentTests#testApplyTopFixedRotationTransform

Change-Id: Id370d7980d11553905b6a051482e3765ed61dc39
---
 .../com/android/server/wm/DisplayContent.java | 94 ++++++++++++-------
 .../com/android/server/wm/WindowToken.java    | 36 +++----
 .../server/wm/DisplayContentTests.java        | 32 +++++--
 .../wm/RecentsAnimationControllerTest.java    |  4 -
 .../android/server/wm/WindowTokenTests.java   |  4 +-
 5 files changed, 101 insertions(+), 69 deletions(-)

diff --git a/services/core/java/com/android/server/wm/DisplayContent.java b/services/core/java/com/android/server/wm/DisplayContent.java
index c41029b206515..5b2ccf43833da 100644
--- a/services/core/java/com/android/server/wm/DisplayContent.java
+++ b/services/core/java/com/android/server/wm/DisplayContent.java
@@ -498,6 +498,9 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo
      */
     ActivityRecord mFixedRotationLaunchingApp;
 
+    final FixedRotationTransitionListener mFixedRotationTransitionListener =
+            new FixedRotationTransitionListener();
+
     /** Windows added since {@link #mCurrentFocus} was set to null. Used for ANR blaming. */
     final ArrayList<WindowState> mWinAddedSinceNullFocus = new ArrayList<>();
 
@@ -928,6 +931,7 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo
 
         mAppTransition = new AppTransition(mWmService.mContext, mWmService, this);
         mAppTransition.registerListenerLocked(mWmService.mActivityManagerAppTransitionNotifier);
+        mAppTransition.registerListenerLocked(mFixedRotationTransitionListener);
         mAppTransitionController = new AppTransitionController(mWmService, this);
         mUnknownAppVisibilityController = new UnknownAppVisibilityController(mWmService, this);
 
@@ -1383,7 +1387,6 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo
                 orientationSource != null ? orientationSource.asActivityRecord() : null;
         // Currently there is no use case from non-activity.
         if (r != null && handleTopActivityLaunchingInDifferentOrientation(r)) {
-            mFixedRotationLaunchingApp = r;
             // Display orientation should be deferred until the top fixed rotation is finished.
             return false;
         }
@@ -1448,47 +1451,44 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo
             return false;
         }
 
+        final WindowToken prevRotatedLaunchingApp = mFixedRotationLaunchingApp;
+        if (prevRotatedLaunchingApp != null
+                && prevRotatedLaunchingApp.getWindowConfiguration().getRotation() == rotation
+                // It is animating so we can expect there will have a transition callback.
+                && prevRotatedLaunchingApp.isAnimating(TRANSITION | PARENTS)) {
+            // It may be the case that multiple activities launch consecutively. Because their
+            // rotation are the same, the transformed state can be shared to avoid duplicating
+            // the heavy operations. This also benefits that the states of multiple activities
+            // are handled together.
+            r.linkFixedRotationTransform(prevRotatedLaunchingApp);
+            return true;
+        }
+
         startFixedRotationTransform(r, rotation);
-        mAppTransition.registerListenerLocked(new WindowManagerInternal.AppTransitionListener() {
-            void done() {
-                r.finishFixedRotationTransform();
-                mAppTransition.unregisterListener(this);
-            }
-
-            @Override
-            public void onAppTransitionFinishedLocked(IBinder token) {
-                if (token == r.token) {
-                    done();
-                }
-            }
-
-            @Override
-            public void onAppTransitionCancelledLocked(int transit) {
-                done();
-            }
-
-            @Override
-            public void onAppTransitionTimeoutLocked() {
-                done();
-            }
-        });
+        mFixedRotationLaunchingApp = r;
+        if (prevRotatedLaunchingApp != null) {
+            prevRotatedLaunchingApp.finishFixedRotationTransform();
+        }
         return true;
     }
 
-    /** @return {@code true} if the display orientation will be changed. */
-    boolean continueUpdateOrientationForDiffOrienLaunchingApp(WindowToken token) {
-        if (token != mFixedRotationLaunchingApp) {
-            return false;
+    /**
+     * Continue updating the orientation change of display if it was deferred by a top activity
+     * launched in a different orientation.
+     */
+    void continueUpdateOrientationForDiffOrienLaunchingApp() {
+        if (mFixedRotationLaunchingApp == null) {
+            return;
         }
         // Update directly because the app which will change the orientation of display is ready.
         if (mDisplayRotation.updateOrientation(getOrientation(), false /* forceUpdate */)) {
             sendNewConfiguration();
-            return true;
+            return;
         }
         // The display won't rotate (e.g. the orientation from sensor has updated again before
         // applying rotation to display), so clear it to stop using seamless rotation.
+        mFixedRotationLaunchingApp.finishFixedRotationTransform();
         mFixedRotationLaunchingApp = null;
-        return false;
     }
 
     private void startFixedRotationTransform(WindowToken token, int rotation) {
@@ -5184,7 +5184,7 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo
         final int currRotation = currOverrideConfig.windowConfiguration.getRotation();
         final int overrideRotation = overrideConfiguration.windowConfiguration.getRotation();
         if (currRotation != ROTATION_UNDEFINED && currRotation != overrideRotation) {
-            applyRotationAndClearFixedRotation(currRotation, overrideRotation);
+            applyRotationAndFinishFixedRotation(currRotation, overrideRotation);
         }
         mCurrentOverrideConfigurationChanges = currOverrideConfig.diff(overrideConfiguration);
         super.onRequestedOverrideConfigurationChanged(overrideConfiguration);
@@ -5200,7 +5200,7 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo
      * fixed rotation transform also needs to be cleared to make sure the rotated activity fits
      * the display naturally.
      */
-    private void applyRotationAndClearFixedRotation(int oldRotation, int newRotation) {
+    private void applyRotationAndFinishFixedRotation(int oldRotation, int newRotation) {
         if (mFixedRotationLaunchingApp == null) {
             applyRotation(oldRotation, newRotation);
             return;
@@ -5219,7 +5219,7 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo
             }
         });
 
-        mFixedRotationLaunchingApp.clearFixedRotationTransform(
+        mFixedRotationLaunchingApp.finishFixedRotationTransform(
                 () -> applyRotation(oldRotation, newRotation));
         mFixedRotationLaunchingApp = null;
     }
@@ -5494,6 +5494,34 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo
         });
     }
 
+    /** The entry for proceeding to handle {@link #mFixedRotationLaunchingApp}. */
+    class FixedRotationTransitionListener extends WindowManagerInternal.AppTransitionListener {
+
+        @Override
+        public void onAppTransitionFinishedLocked(IBinder token) {
+            final ActivityRecord r = getActivityRecord(token);
+            if (r == null) {
+                return;
+            }
+            if (mFixedRotationLaunchingApp != null
+                    && mFixedRotationLaunchingApp.hasFixedRotationTransform(r)) {
+                continueUpdateOrientationForDiffOrienLaunchingApp();
+            } else {
+                r.finishFixedRotationTransform();
+            }
+        }
+
+        @Override
+        public void onAppTransitionCancelledLocked(int transit) {
+            continueUpdateOrientationForDiffOrienLaunchingApp();
+        }
+
+        @Override
+        public void onAppTransitionTimeoutLocked() {
+            continueUpdateOrientationForDiffOrienLaunchingApp();
+        }
+    }
+
     class RemoteInsetsControlTarget implements InsetsControlTarget {
         private final IDisplayWindowInsetsController mRemoteInsetsController;
 
diff --git a/services/core/java/com/android/server/wm/WindowToken.java b/services/core/java/com/android/server/wm/WindowToken.java
index 21c76874f5c04..472773e1bb1a2 100644
--- a/services/core/java/com/android/server/wm/WindowToken.java
+++ b/services/core/java/com/android/server/wm/WindowToken.java
@@ -119,7 +119,6 @@ class WindowToken extends WindowContainer<WindowState> {
      * rotated by the given rotated display info, frames and insets.
      */
     private static class FixedRotationTransformState {
-        final WindowToken mOwner;
         final DisplayInfo mDisplayInfo;
         final DisplayFrames mDisplayFrames;
         final InsetsState mInsetsState;
@@ -133,10 +132,9 @@ class WindowToken extends WindowContainer<WindowState> {
         final ArrayList<WindowContainer<?>> mRotatedContainers = new ArrayList<>(3);
         boolean mIsTransforming = true;
 
-        FixedRotationTransformState(WindowToken owner, DisplayInfo rotatedDisplayInfo,
+        FixedRotationTransformState(DisplayInfo rotatedDisplayInfo,
                 DisplayFrames rotatedDisplayFrames, InsetsState rotatedInsetsState,
                 Configuration rotatedConfig, int currentRotation) {
-            mOwner = owner;
             mDisplayInfo = rotatedDisplayInfo;
             mDisplayFrames = rotatedDisplayFrames;
             mInsetsState = rotatedInsetsState;
@@ -482,6 +480,14 @@ class WindowToken extends WindowContainer<WindowState> {
         return mFixedRotationTransformState != null;
     }
 
+    /** Returns {@code true} if the given token shares the same transform. */
+    boolean hasFixedRotationTransform(WindowToken token) {
+        if (mFixedRotationTransformState == null || token == null) {
+            return false;
+        }
+        return this == token || mFixedRotationTransformState == token.mFixedRotationTransformState;
+    }
+
     boolean isFinishingFixedRotationTransform() {
         return mFixedRotationTransformState != null
                 && !mFixedRotationTransformState.mIsTransforming;
@@ -520,15 +526,14 @@ class WindowToken extends WindowContainer<WindowState> {
         final InsetsState insetsState = new InsetsState();
         mDisplayContent.getDisplayPolicy().simulateLayoutDisplay(displayFrames, insetsState,
                 mDisplayContent.getConfiguration().uiMode);
-        mFixedRotationTransformState = new FixedRotationTransformState(this, info, displayFrames,
+        mFixedRotationTransformState = new FixedRotationTransformState(info, displayFrames,
                 insetsState, new Configuration(config), mDisplayContent.getRotation());
         onConfigurationChanged(getParent().getConfiguration());
     }
 
     /**
      * Reuses the {@link FixedRotationTransformState} (if any) from the other WindowToken to this
-     * one. This takes the same effect as {@link #applyFixedRotationTransform}, but the linked state
-     * can only be cleared by the state owner.
+     * one. This takes the same effect as {@link #applyFixedRotationTransform}.
      */
     void linkFixedRotationTransform(WindowToken other) {
         if (mFixedRotationTransformState != null) {
@@ -543,28 +548,15 @@ class WindowToken extends WindowContainer<WindowState> {
         onConfigurationChanged(getParent().getConfiguration());
     }
 
-    /**
-     * Finishes the transform and continue updating the orientation change of display. Only the
-     * state owner can finish the transform state.
-     */
     void finishFixedRotationTransform() {
-        if (mFixedRotationTransformState == null || mFixedRotationTransformState.mOwner != this) {
-            return;
-        }
-        final boolean changed =
-                mDisplayContent.continueUpdateOrientationForDiffOrienLaunchingApp(this);
-        // If it is not the launching app or the display is not rotated, make sure the transform is
-        // cleared and the configuration is restored from parent.
-        if (!changed) {
-            clearFixedRotationTransform(null /* applyDisplayRotation */);
-        }
+        finishFixedRotationTransform(null /* applyDisplayRotation */);
     }
 
     /**
-     * Clears the transform and apply display rotation if the action is given. If the display will
+     * Finishes the transform and apply display rotation if the action is given. If the display will
      * not rotate, the transformed containers are restored to their original states.
      */
-    void clearFixedRotationTransform(Runnable applyDisplayRotation) {
+    void finishFixedRotationTransform(Runnable applyDisplayRotation) {
         final FixedRotationTransformState state = mFixedRotationTransformState;
         if (state == null) {
             return;
diff --git a/services/tests/wmtests/src/com/android/server/wm/DisplayContentTests.java b/services/tests/wmtests/src/com/android/server/wm/DisplayContentTests.java
index e02ea813cdd7b..cba89d0aea2d2 100644
--- a/services/tests/wmtests/src/com/android/server/wm/DisplayContentTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/DisplayContentTests.java
@@ -790,9 +790,7 @@ public class DisplayContentTests extends WindowTestsBase {
         final DisplayContent dc = createNewDisplay();
         dc.getDisplayRotation().setFixedToUserRotation(
                 IWindowManager.FIXED_TO_USER_ROTATION_DISABLED);
-        final int newOrientation = dc.getLastOrientation() == SCREEN_ORIENTATION_LANDSCAPE
-                ? SCREEN_ORIENTATION_PORTRAIT
-                : SCREEN_ORIENTATION_LANDSCAPE;
+        final int newOrientation = getRotatedOrientation(dc);
 
         final ActivityStack stack =
                 new ActivityTestsBase.StackBuilder(mWm.mAtmService.mRootWindowContainer)
@@ -812,9 +810,7 @@ public class DisplayContentTests extends WindowTestsBase {
         final DisplayContent dc = createNewDisplay();
         dc.getDisplayRotation().setFixedToUserRotation(
                 IWindowManager.FIXED_TO_USER_ROTATION_ENABLED);
-        final int newOrientation = dc.getLastOrientation() == SCREEN_ORIENTATION_LANDSCAPE
-                ? SCREEN_ORIENTATION_PORTRAIT
-                : SCREEN_ORIENTATION_LANDSCAPE;
+        final int newOrientation = getRotatedOrientation(dc);
 
         final ActivityStack stack =
                 new ActivityTestsBase.StackBuilder(mWm.mAtmService.mRootWindowContainer)
@@ -1083,7 +1079,8 @@ public class DisplayContentTests extends WindowTestsBase {
         mDisplayContent.prepareAppTransition(WindowManager.TRANSIT_ACTIVITY_OPEN,
                 false /* alwaysKeepCurrent */);
         mDisplayContent.mOpeningApps.add(app);
-        app.setRequestedOrientation(SCREEN_ORIENTATION_LANDSCAPE);
+        final int newOrientation = getRotatedOrientation(mDisplayContent);
+        app.setRequestedOrientation(newOrientation);
 
         assertTrue(app.isFixedRotationTransforming());
         assertTrue(mDisplayContent.getDisplayRotation().shouldRotateSeamlessly(
@@ -1124,12 +1121,25 @@ public class DisplayContentTests extends WindowTestsBase {
         mWallpaperWindow.mToken.onAnimationLeashCreated(t, null /* leash */);
         verify(t, never()).setPosition(any(), eq(0), eq(0));
 
+        // Launch another activity before the transition is finished.
+        final ActivityRecord app2 = new ActivityTestsBase.StackBuilder(mWm.mRoot)
+                .setDisplay(mDisplayContent).build().getTopMostActivity();
+        mDisplayContent.prepareAppTransition(WindowManager.TRANSIT_ACTIVITY_OPEN,
+                false /* alwaysKeepCurrent */);
+        mDisplayContent.mOpeningApps.add(app2);
+        app2.setRequestedOrientation(newOrientation);
+
+        // The activity should share the same transform state as the existing one.
+        assertTrue(app.hasFixedRotationTransform(app2));
+
+        // The display should be rotated after the launch is finished.
         mDisplayContent.mAppTransition.notifyAppTransitionFinishedLocked(app.token);
 
         // The animation in old rotation should be cancelled.
         assertFalse(closingApp.isAnimating());
-        // The display should be rotated after the launch is finished.
+        // The fixed rotation should be cleared and the new rotation is applied to display.
         assertFalse(app.hasFixedRotationTransform());
+        assertFalse(app2.hasFixedRotationTransform());
         assertEquals(config90.orientation, mDisplayContent.getConfiguration().orientation);
     }
 
@@ -1292,6 +1302,12 @@ public class DisplayContentTests extends WindowTestsBase {
         assertThat("topToBottom", actualWindows, is(reverseList(expectedWindowsBottomToTop)));
     }
 
+    private static int getRotatedOrientation(DisplayContent dc) {
+        return dc.getLastOrientation() == SCREEN_ORIENTATION_LANDSCAPE
+                ? SCREEN_ORIENTATION_PORTRAIT
+                : SCREEN_ORIENTATION_LANDSCAPE;
+    }
+
     private static List<WindowState> reverseList(List<WindowState> list) {
         final ArrayList<WindowState> result = new ArrayList<>(list);
         Collections.reverse(result);
diff --git a/services/tests/wmtests/src/com/android/server/wm/RecentsAnimationControllerTest.java b/services/tests/wmtests/src/com/android/server/wm/RecentsAnimationControllerTest.java
index f19550ced0bf7..409889b660b76 100644
--- a/services/tests/wmtests/src/com/android/server/wm/RecentsAnimationControllerTest.java
+++ b/services/tests/wmtests/src/com/android/server/wm/RecentsAnimationControllerTest.java
@@ -401,10 +401,6 @@ public class RecentsAnimationControllerTest extends WindowTestsBase {
         assertEquals(Configuration.ORIENTATION_PORTRAIT,
                 wallpapers.get(0).getConfiguration().orientation);
 
-        // Wallpaper's transform state is controlled by home, so the invocation should be no-op.
-        wallpaperWindowToken.finishFixedRotationTransform();
-        assertTrue(wallpaperWindowToken.hasFixedRotationTransform());
-
         // Wallpaper's transform state should be cleared with home.
         homeActivity.finishFixedRotationTransform();
         assertFalse(wallpaperWindowToken.hasFixedRotationTransform());
diff --git a/services/tests/wmtests/src/com/android/server/wm/WindowTokenTests.java b/services/tests/wmtests/src/com/android/server/wm/WindowTokenTests.java
index 535d53eeef719..23a097eb0c7ce 100644
--- a/services/tests/wmtests/src/com/android/server/wm/WindowTokenTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/WindowTokenTests.java
@@ -136,7 +136,7 @@ public class WindowTokenTests extends WindowTestsBase {
     }
 
     @Test
-    public void testClearFixedRotationTransform() {
+    public void testFinishFixedRotationTransform() {
         final WindowToken appToken = mAppWindow.mToken;
         final WindowToken wallpaperToken = mWallpaperWindow.mToken;
         final Configuration config = new Configuration(mDisplayContent.getConfiguration());
@@ -152,7 +152,7 @@ public class WindowTokenTests extends WindowTestsBase {
         assertEquals(targetRotation, wallpaperToken.getWindowConfiguration().getRotation());
 
         // The display doesn't rotate, the transformation will be canceled.
-        mAppWindow.mToken.clearFixedRotationTransform(null /* applyDisplayRotation */);
+        mAppWindow.mToken.finishFixedRotationTransform();
 
         // The window tokens should restore to the original rotation.
         assertEquals(originalRotation, appToken.getWindowConfiguration().getRotation());

From cbc5d2721b8f97e619f4bcf63cb6c58c6f2e7580 Mon Sep 17 00:00:00 2001
From: Riddle Hsu <riddlehsu@google.com>
Date: Fri, 24 Apr 2020 23:26:46 +0800
Subject: [PATCH 2/3] Polish fixed rotated recents animation

For the cases that move recents or home to top, the transformed
state is kept until the transition of task-to-front is done.

This fixes the flickering when switching between recents and the
activity that supported PiP. Also eliminated an additional toggle
of fixed rotation transform from finishing recents animation.

Fixes: 154588225
Test: atest RecentsAnimationControllerTest

Change-Id: I92c6dfac1d030f76f62a10bd0596f935adffb63c
---
 .../com/android/server/wm/DisplayContent.java | 60 +++++++++++++++++--
 .../server/wm/RecentsAnimationController.java | 11 ++--
 .../wm/RecentsAnimationControllerTest.java    | 18 +++++-
 3 files changed, 78 insertions(+), 11 deletions(-)

diff --git a/services/core/java/com/android/server/wm/DisplayContent.java b/services/core/java/com/android/server/wm/DisplayContent.java
index 5b2ccf43833da..a1620fe410c77 100644
--- a/services/core/java/com/android/server/wm/DisplayContent.java
+++ b/services/core/java/com/android/server/wm/DisplayContent.java
@@ -494,6 +494,7 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo
      * The launching activity which is using fixed rotation transformation.
      *
      * @see #handleTopActivityLaunchingInDifferentOrientation
+     * @see #setFixedRotationLaunchingApp
      * @see DisplayRotation#shouldRotateSeamlessly
      */
     ActivityRecord mFixedRotationLaunchingApp;
@@ -1451,6 +1452,15 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo
             return false;
         }
 
+        setFixedRotationLaunchingApp(r, rotation);
+        return true;
+    }
+
+    /**
+     * Sets the provided record to {@link mFixedRotationLaunchingApp} if possible to apply fixed
+     * rotation transform to it and indicate that the display may be rotated after it is launched.
+     */
+    void setFixedRotationLaunchingApp(@NonNull ActivityRecord r, @Surface.Rotation int rotation) {
         final WindowToken prevRotatedLaunchingApp = mFixedRotationLaunchingApp;
         if (prevRotatedLaunchingApp != null
                 && prevRotatedLaunchingApp.getWindowConfiguration().getRotation() == rotation
@@ -1461,15 +1471,16 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo
             // the heavy operations. This also benefits that the states of multiple activities
             // are handled together.
             r.linkFixedRotationTransform(prevRotatedLaunchingApp);
-            return true;
+            return;
         }
 
-        startFixedRotationTransform(r, rotation);
+        if (!r.hasFixedRotationTransform()) {
+            startFixedRotationTransform(r, rotation);
+        }
         mFixedRotationLaunchingApp = r;
         if (prevRotatedLaunchingApp != null) {
             prevRotatedLaunchingApp.finishFixedRotationTransform();
         }
-        return true;
     }
 
     /**
@@ -5497,10 +5508,51 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo
     /** The entry for proceeding to handle {@link #mFixedRotationLaunchingApp}. */
     class FixedRotationTransitionListener extends WindowManagerInternal.AppTransitionListener {
 
+        /**
+         * The animating activity which shows the recents task list. It is set between
+         * {@link RecentsAnimationController#initialize} and
+         * {@link RecentsAnimationController#cancelAnimation}.
+         */
+        private ActivityRecord mAnimatingRecents;
+
+        /**
+         * If the recents activity has a fixed orientation which is different from the current top
+         * activity, it will be rotated before being shown so we avoid a screen rotation animation
+         * when showing the Recents view.
+         */
+        void onStartRecentsAnimation(@NonNull ActivityRecord r) {
+            mAnimatingRecents = r;
+            rotateInDifferentOrientationIfNeeded(r);
+            if (r.hasFixedRotationTransform()) {
+                // Set the record so we can recognize it to continue to update display orientation
+                // if the recents activity becomes the top later.
+                setFixedRotationLaunchingApp(r, r.getWindowConfiguration().getRotation());
+            }
+        }
+
+        /**
+         * If {@link #mAnimatingRecents} still has fixed rotation, it should be moved to top so we
+         * don't clear {@link #mFixedRotationLaunchingApp} that will be handled by transition.
+         */
+        void onFinishRecentsAnimation() {
+            final ActivityRecord animatingRecents = mAnimatingRecents;
+            mAnimatingRecents = null;
+            if (animatingRecents != null && animatingRecents == mFixedRotationLaunchingApp
+                    && !animatingRecents.hasFixedRotationTransform()) {
+                // The recents activity won't be the top, such as giving up the swipe up gesture
+                // and return to the original top.
+                mFixedRotationLaunchingApp = null;
+            }
+        }
+
         @Override
         public void onAppTransitionFinishedLocked(IBinder token) {
             final ActivityRecord r = getActivityRecord(token);
-            if (r == null) {
+            // Ignore the animating recents so the fixed rotation transform won't be switched twice
+            // by finishing the recents animation and moving it to top. That also avoids flickering
+            // due to wait for previous activity to be paused if it supports PiP that ignores the
+            // effect of resume-while-pausing.
+            if (r == null || r == mAnimatingRecents) {
                 return;
             }
             if (mFixedRotationLaunchingApp != null
diff --git a/services/core/java/com/android/server/wm/RecentsAnimationController.java b/services/core/java/com/android/server/wm/RecentsAnimationController.java
index 6efa8de86c284..dd761bec0f160 100644
--- a/services/core/java/com/android/server/wm/RecentsAnimationController.java
+++ b/services/core/java/com/android/server/wm/RecentsAnimationController.java
@@ -411,10 +411,7 @@ public class RecentsAnimationController implements DeathRecipient {
 
         mService.mWindowPlacerLocked.performSurfacePlacement();
 
-        // If the target activity has a fixed orientation which is different from the current top
-        // activity, it will be rotated before being shown so we avoid a screen rotation
-        // animation when showing the Recents view.
-        mDisplayContent.rotateInDifferentOrientationIfNeeded(mTargetActivityRecord);
+        mDisplayContent.mFixedRotationTransitionListener.onStartRecentsAnimation(targetActivity);
 
         // Notify that the animation has started
         if (mStatusBar != null) {
@@ -736,11 +733,13 @@ public class RecentsAnimationController implements DeathRecipient {
             if (reorderMode == REORDER_MOVE_TO_TOP || reorderMode == REORDER_KEEP_IN_PLACE) {
                 mDisplayContent.mAppTransition.notifyAppTransitionFinishedLocked(
                         mTargetActivityRecord.token);
-            }
-            if (mTargetActivityRecord.hasFixedRotationTransform()) {
+            } else {
+                // The target activity will be moved to original position (non-top). Since it won't
+                // affect display orientation, just finish the transform.
                 mTargetActivityRecord.finishFixedRotationTransform();
             }
         }
+        mDisplayContent.mFixedRotationTransitionListener.onFinishRecentsAnimation();
 
         // Notify that the animation has ended
         if (mStatusBar != null) {
diff --git a/services/tests/wmtests/src/com/android/server/wm/RecentsAnimationControllerTest.java b/services/tests/wmtests/src/com/android/server/wm/RecentsAnimationControllerTest.java
index 409889b660b76..906646894ee0f 100644
--- a/services/tests/wmtests/src/com/android/server/wm/RecentsAnimationControllerTest.java
+++ b/services/tests/wmtests/src/com/android/server/wm/RecentsAnimationControllerTest.java
@@ -344,9 +344,17 @@ public class RecentsAnimationControllerTest extends WindowTestsBase {
 
         mController.initialize(ACTIVITY_TYPE_HOME, new SparseBooleanArray(), homeActivity);
 
+        assertEquals(homeActivity, mDefaultDisplay.mFixedRotationLaunchingApp);
+
         // Check that the home app is in portrait
         assertEquals(Configuration.ORIENTATION_PORTRAIT,
                 homeActivity.getConfiguration().orientation);
+
+        // Home activity won't become top (return to landActivity), so its fixed rotation and the
+        // top rotated record should be cleared.
+        mController.cleanupAnimation(REORDER_MOVE_TO_ORIGINAL_POSITION);
+        assertFalse(homeActivity.hasFixedRotationTransform());
+        assertNull(mDefaultDisplay.mFixedRotationLaunchingApp);
     }
 
     @Test
@@ -401,8 +409,16 @@ public class RecentsAnimationControllerTest extends WindowTestsBase {
         assertEquals(Configuration.ORIENTATION_PORTRAIT,
                 wallpapers.get(0).getConfiguration().orientation);
 
+        mController.cleanupAnimation(REORDER_MOVE_TO_TOP);
+        // The transform state should keep because we expect to listen the signal from the
+        // transition executed by moving the task to front.
+        assertTrue(homeActivity.hasFixedRotationTransform());
+        assertEquals(homeActivity, mDefaultDisplay.mFixedRotationLaunchingApp);
+
+        mDefaultDisplay.mFixedRotationTransitionListener.onAppTransitionFinishedLocked(
+                homeActivity.token);
         // Wallpaper's transform state should be cleared with home.
-        homeActivity.finishFixedRotationTransform();
+        assertFalse(homeActivity.hasFixedRotationTransform());
         assertFalse(wallpaperWindowToken.hasFixedRotationTransform());
     }
 

From b40f96623267d59b9cf8ae6f565668d6e3ec435d Mon Sep 17 00:00:00 2001
From: Riddle Hsu <riddlehsu@google.com>
Date: Sat, 25 Apr 2020 01:58:23 +0800
Subject: [PATCH 3/3] Clear fixed rotation if display config does not change

There is a timing that when remote rotation is completed, the
orientation from sensor has been updated again. If the transition
of rotated app hasn't complete, the display is still in previous
orientation, then if it is the same as the last value from sensor,
the display configuration does not change. So in this case the
rotated app needs to be restored to avoid showing different
orientation than the display.

Fixes: 153327533
Test: ActivityRecordTests#testActivityOnCancelFixedRotationTransform
Test: Add delay to execute DisplayRotation#continueRotation.
      Put device in landscape with a portrait home on top, launch an
      activity without fixed orientation, and then rotate the device
      to portrait immediately. The activity should launch in landscape
      and rotate to portrait with animation.

Change-Id: Ic966923a751d94cc6ea86a83c2f600424999799c
---
 .../com/android/server/wm/DisplayContent.java | 25 +++++++++++++++++--
 .../server/wm/ActivityRecordTests.java        | 14 ++++++++++-
 2 files changed, 36 insertions(+), 3 deletions(-)

diff --git a/services/core/java/com/android/server/wm/DisplayContent.java b/services/core/java/com/android/server/wm/DisplayContent.java
index a1620fe410c77..c66ff330edbdf 100644
--- a/services/core/java/com/android/server/wm/DisplayContent.java
+++ b/services/core/java/com/android/server/wm/DisplayContent.java
@@ -1271,6 +1271,12 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo
         if (configUpdated) {
             return;
         }
+
+        // The display configuration doesn't change. If there is a launching transformed app, that
+        // means its request to change display configuration has been discarded, then it should
+        // respect to the current configuration of display.
+        clearFixedRotationLaunchingApp();
+
         // Something changed (E.g. device rotation), but no configuration update is needed.
         // E.g. changing device rotation by 180 degrees. Go ahead and perform surface placement to
         // unfreeze the display since we froze it when the rotation was updated in
@@ -1496,8 +1502,20 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo
             sendNewConfiguration();
             return;
         }
-        // The display won't rotate (e.g. the orientation from sensor has updated again before
-        // applying rotation to display), so clear it to stop using seamless rotation.
+        // The orientation of display is not changed.
+        clearFixedRotationLaunchingApp();
+    }
+
+    /**
+     * Clears the {@link mFixedRotationLaunchingApp} without applying rotation to display. It is
+     * used when the display won't rotate (e.g. the orientation from sensor has updated again before
+     * applying rotation to display) but the launching app has been transformed. So the record need
+     * to be cleared and restored to stop using seamless rotation and rotated configuration.
+     */
+    private void clearFixedRotationLaunchingApp() {
+        if (mFixedRotationLaunchingApp == null) {
+            return;
+        }
         mFixedRotationLaunchingApp.finishFixedRotationTransform();
         mFixedRotationLaunchingApp = null;
     }
@@ -2869,6 +2887,9 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo
             pw.print("  mLastStatusBarVisibility=0x");
             pw.println(Integer.toHexString(mLastStatusBarVisibility));
         }
+        if (mFixedRotationLaunchingApp != null) {
+            pw.println("  mFixedRotationLaunchingApp=" + mFixedRotationLaunchingApp);
+        }
 
         pw.println();
         mWallpaperController.dump(pw, "  ");
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 6a28918eab005..394c55612a351 100644
--- a/services/tests/wmtests/src/com/android/server/wm/ActivityRecordTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/ActivityRecordTests.java
@@ -66,6 +66,7 @@ import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.ArgumentMatchers.anyInt;
 import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.clearInvocations;
 import static org.mockito.Mockito.never;
 
 import android.app.ActivityOptions;
@@ -1362,6 +1363,7 @@ public class ActivityRecordTests extends ActivityTestsBase {
         final DisplayInfo rotatedInfo = mActivity.getFixedRotationTransformDisplayInfo();
         mActivity.finishFixedRotationTransform();
         final ScreenRotationAnimation rotationAnim = display.getRotationAnimation();
+        assertNotNull(rotationAnim);
         rotationAnim.setRotation(display.getPendingTransaction(), originalRotation);
 
         // Because the display doesn't rotate, the rotated activity needs to cancel the fixed
@@ -1369,8 +1371,18 @@ public class ActivityRecordTests extends ActivityTestsBase {
         verify(mActivity).onCancelFixedRotationTransform(rotatedInfo.rotation);
         assertTrue(mActivity.isFreezingScreen());
         assertFalse(displayRotation.isRotatingSeamlessly());
-        assertNotNull(rotationAnim);
         assertTrue(rotationAnim.isRotating());
+
+        // Simulate the remote rotation has completed and the configuration doesn't change, then
+        // the rotated activity should also be restored by clearing the transform.
+        displayRotation.updateRotationUnchecked(true /* forceUpdate */);
+        doReturn(false).when(displayRotation).isWaitingForRemoteRotation();
+        clearInvocations(mActivity);
+        display.mFixedRotationLaunchingApp = mActivity;
+        display.sendNewConfiguration();
+
+        assertNull(display.mFixedRotationLaunchingApp);
+        assertFalse(mActivity.hasFixedRotationTransform());
     }
 
     @Test