Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit f4ee939a authored by Riddle Hsu's avatar Riddle Hsu Committed by Automerger Merge Worker
Browse files

Finish fixed rotation after recents moved to top am: 5a5734bb

Original change: https://googleplex-android-review.googlesource.com/c/platform/frameworks/base/+/12468083

Change-Id: If32a5d87f3d99a94eade0e0f0b59192a119ec862
parents c0c15697 5a5734bb
Loading
Loading
Loading
Loading
+19 −2
Original line number Original line Diff line number Diff line
@@ -5642,6 +5642,9 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo
         */
         */
        private ActivityRecord mAnimatingRecents;
        private ActivityRecord mAnimatingRecents;


        /** Whether {@link #mAnimatingRecents} is going to be the top activity. */
        private boolean mRecentsWillBeTop;

        /**
        /**
         * If the recents activity has a fixed orientation which is different from the current top
         * 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
         * activity, it will be rotated before being shown so we avoid a screen rotation animation
@@ -5667,10 +5670,12 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo
         * If {@link #mAnimatingRecents} still has fixed rotation, it should be moved to top so we
         * 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.
         * don't clear {@link #mFixedRotationLaunchingApp} that will be handled by transition.
         */
         */
        void onFinishRecentsAnimation(boolean moveRecentsToBack) {
        void onFinishRecentsAnimation() {
            final ActivityRecord animatingRecents = mAnimatingRecents;
            final ActivityRecord animatingRecents = mAnimatingRecents;
            final boolean recentsWillBeTop = mRecentsWillBeTop;
            mAnimatingRecents = null;
            mAnimatingRecents = null;
            if (!moveRecentsToBack) {
            mRecentsWillBeTop = false;
            if (recentsWillBeTop) {
                // The recents activity will be the top, such as staying at recents list or
                // The recents activity will be the top, such as staying at recents list or
                // returning to home (if home and recents are the same activity).
                // returning to home (if home and recents are the same activity).
                return;
                return;
@@ -5693,6 +5698,10 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo
            }
            }
        }
        }


        void notifyRecentsWillBeTop() {
            mRecentsWillBeTop = true;
        }

        /**
        /**
         * Return {@code true} if there is an ongoing animation to the "Recents" activity and this
         * Return {@code true} if there is an ongoing animation to the "Recents" activity and this
         * activity as a fixed orientation so shouldn't be rotated.
         * activity as a fixed orientation so shouldn't be rotated.
@@ -5713,6 +5722,14 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo
            if (r == null || r == mAnimatingRecents) {
            if (r == null || r == mAnimatingRecents) {
                return;
                return;
            }
            }
            if (mAnimatingRecents != null && mRecentsWillBeTop) {
                // The activity is not the recents and it should be moved to back later, so it is
                // better to keep its current appearance for the next transition. Otherwise the
                // display orientation may be updated too early and the layout procedures at the
                // end of finishing recents animation is skipped. That causes flickering because
                // the surface of closing app hasn't updated to invisible.
                return;
            }
            if (mFixedRotationLaunchingApp == null) {
            if (mFixedRotationLaunchingApp == null) {
                // In most cases this is a no-op if the activity doesn't have fixed rotation.
                // In most cases this is a no-op if the activity doesn't have fixed rotation.
                // Otherwise it could be from finishing recents animation while the display has
                // Otherwise it could be from finishing recents animation while the display has
+6 −2
Original line number Original line Diff line number Diff line
@@ -702,6 +702,11 @@ public class RecentsAnimationController implements DeathRecipient {
                        "cleanupAnimation(): Notify animation finished mPendingAnimations=%d "
                        "cleanupAnimation(): Notify animation finished mPendingAnimations=%d "
                                + "reorderMode=%d",
                                + "reorderMode=%d",
                        mPendingAnimations.size(), reorderMode);
                        mPendingAnimations.size(), reorderMode);
        if (reorderMode != REORDER_MOVE_TO_ORIGINAL_POSITION) {
            // Notify the state at the beginning because the removeAnimation may notify the
            // transition is finished. This is a signal that there will be a next transition.
            mDisplayContent.mFixedRotationTransitionListener.notifyRecentsWillBeTop();
        }
        for (int i = mPendingAnimations.size() - 1; i >= 0; i--) {
        for (int i = mPendingAnimations.size() - 1; i >= 0; i--) {
            final TaskAnimationAdapter taskAdapter = mPendingAnimations.get(i);
            final TaskAnimationAdapter taskAdapter = mPendingAnimations.get(i);
            if (reorderMode == REORDER_MOVE_TO_TOP || reorderMode == REORDER_KEEP_IN_PLACE) {
            if (reorderMode == REORDER_MOVE_TO_TOP || reorderMode == REORDER_KEEP_IN_PLACE) {
@@ -742,8 +747,7 @@ public class RecentsAnimationController implements DeathRecipient {
                        mTargetActivityRecord.token);
                        mTargetActivityRecord.token);
            }
            }
        }
        }
        mDisplayContent.mFixedRotationTransitionListener.onFinishRecentsAnimation(
        mDisplayContent.mFixedRotationTransitionListener.onFinishRecentsAnimation();
                reorderMode == REORDER_MOVE_TO_ORIGINAL_POSITION /* moveRecentsToBack */);


        // Notify that the animation has ended
        // Notify that the animation has ended
        if (mStatusBar != null) {
        if (mStatusBar != null) {
+1 −1
Original line number Original line Diff line number Diff line
@@ -1282,7 +1282,7 @@ public class DisplayContentTests extends WindowTestsBase {
        assertFalse(displayRotation.updateRotationUnchecked(false));
        assertFalse(displayRotation.updateRotationUnchecked(false));


        // Rotation can be updated if the recents animation is finished.
        // Rotation can be updated if the recents animation is finished.
        mDisplayContent.mFixedRotationTransitionListener.onFinishRecentsAnimation(false);
        mDisplayContent.mFixedRotationTransitionListener.onFinishRecentsAnimation();
        assertTrue(displayRotation.updateRotationUnchecked(false));
        assertTrue(displayRotation.updateRotationUnchecked(false));


        // Rotation can be updated if the recents animation is animating but it is not on top, e.g.
        // Rotation can be updated if the recents animation is animating but it is not on top, e.g.
+27 −2
Original line number Original line Diff line number Diff line
@@ -363,12 +363,14 @@ public class RecentsAnimationControllerTest extends WindowTestsBase {
        assertFalse(homeActivity.hasFixedRotationTransform());
        assertFalse(homeActivity.hasFixedRotationTransform());
    }
    }


    @Test
    private ActivityRecord prepareFixedRotationLaunchingAppWithRecentsAnim() {
    public void testClearFixedRotationLaunchingAppAfterCleanupAnimation() {
        final ActivityRecord homeActivity = createHomeActivity();
        final ActivityRecord homeActivity = createHomeActivity();
        homeActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
        homeActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
        final ActivityRecord activity = createActivityRecord(mDefaultDisplay,
        final ActivityRecord activity = createActivityRecord(mDefaultDisplay,
                WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD);
                WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD);
        // Add a window so it can be animated by the recents.
        final WindowState win = createWindow(null, TYPE_BASE_APPLICATION, activity, "win");
        activity.addWindow(win);
        // Assume an activity is launching to different rotation.
        // Assume an activity is launching to different rotation.
        mDefaultDisplay.setFixedRotationLaunchingApp(activity,
        mDefaultDisplay.setFixedRotationLaunchingApp(activity,
                (mDefaultDisplay.getRotation() + 1) % 4);
                (mDefaultDisplay.getRotation() + 1) % 4);
@@ -379,6 +381,14 @@ public class RecentsAnimationControllerTest extends WindowTestsBase {
        // Before the transition is done, the recents animation is triggered.
        // Before the transition is done, the recents animation is triggered.
        initializeRecentsAnimationController(mController, homeActivity);
        initializeRecentsAnimationController(mController, homeActivity);
        assertFalse(homeActivity.hasFixedRotationTransform());
        assertFalse(homeActivity.hasFixedRotationTransform());
        assertTrue(mController.isAnimatingTask(activity.getTask()));

        return activity;
    }

    @Test
    public void testClearFixedRotationLaunchingAppAfterCleanupAnimation() {
        final ActivityRecord activity = prepareFixedRotationLaunchingAppWithRecentsAnim();


        // Simulate giving up the swipe up gesture to keep the original activity as top.
        // Simulate giving up the swipe up gesture to keep the original activity as top.
        mController.cleanupAnimation(REORDER_MOVE_TO_ORIGINAL_POSITION);
        mController.cleanupAnimation(REORDER_MOVE_TO_ORIGINAL_POSITION);
@@ -387,6 +397,21 @@ public class RecentsAnimationControllerTest extends WindowTestsBase {
        assertFalse(mDefaultDisplay.hasTopFixedRotationLaunchingApp());
        assertFalse(mDefaultDisplay.hasTopFixedRotationLaunchingApp());
    }
    }


    @Test
    public void testKeepFixedRotationWhenMovingRecentsToTop() {
        final ActivityRecord activity = prepareFixedRotationLaunchingAppWithRecentsAnim();
        // Assume a transition animation has started running before recents animation. Then the
        // activity will receive onAnimationFinished that notifies app transition finished when
        // removing the recents animation of task.
        activity.getTask().getAnimationSources().add(activity);

        // Simulate swiping to home/recents before the transition is done.
        mController.cleanupAnimation(REORDER_MOVE_TO_TOP);
        // The rotation transform should be preserved. In real case, it will be cleared by the next
        // move-to-top transition.
        assertTrue(activity.hasFixedRotationTransform());
    }

    @Test
    @Test
    public void testWallpaperHasFixedRotationApplied() {
    public void testWallpaperHasFixedRotationApplied() {
        mWm.setRecentsAnimationController(mController);
        mWm.setRecentsAnimationController(mController);