From 2e53f5ef97a02d25f508774e82985e24dc2f4d2d Mon Sep 17 00:00:00 2001 From: Nick Chameyev Date: Fri, 26 May 2023 11:50:13 +0100 Subject: [PATCH] [Unfold animation] Do not preemptively start the animation if it has run already Currently if we open an app, unfold the device and then go to home screen we will start the unfold animation preemptively in Launcher because Launcher activity will receive updated configuration change (where isTablet = true) only after going back to home screen, not when unfolding the device. This causes a problem because SystemUI won't send the unfold animation events after going back home as the animation has already run, so we end up with wrongly started animation in Launcher. This CL fixes the issues by checking if SystemUI has finished the animation (or if it is currently running) to avoid preemptive animation start in this case. This is done by subscribing to the original unfold transition progress provider which emits progress events sent through IPC from SystemUI. Bug: 285150685 Bug: 293131586 Test: open an app on folded screen, unfold, go to home screen => check that icons are not squished Test: fold/unfold when launcher is open Change-Id: Ic437ff4d19cbd5764635f3007d99880622150f5b Merged-In: Ic437ff4d19cbd5764635f3007d99880622150f5b (cherry picked from commit 6d756970e77e99ed434c58b815a6eaac1a023a4c) --- .../uioverrides/QuickstepLauncher.java | 4 ++ .../LauncherUnfoldAnimationController.java | 65 ++++++++++++++++++- .../launcher3/config/FeatureFlags.java | 2 +- 3 files changed, 69 insertions(+), 2 deletions(-) diff --git a/quickstep/src/com/android/launcher3/uioverrides/QuickstepLauncher.java b/quickstep/src/com/android/launcher3/uioverrides/QuickstepLauncher.java index 2f13c5de44..3139e4d91a 100644 --- a/quickstep/src/com/android/launcher3/uioverrides/QuickstepLauncher.java +++ b/quickstep/src/com/android/launcher3/uioverrides/QuickstepLauncher.java @@ -472,6 +472,10 @@ public class QuickstepLauncher extends Launcher { public void onDestroy() { mAppTransitionManager.onActivityDestroyed(); if (mUnfoldTransitionProgressProvider != null) { + if (FeatureFlags.RECEIVE_UNFOLD_EVENTS_FROM_SYSUI.get()) { + SystemUiProxy.INSTANCE.get(this).setUnfoldAnimationListener(null); + } + mUnfoldTransitionProgressProvider.destroy(); } diff --git a/quickstep/src/com/android/quickstep/util/LauncherUnfoldAnimationController.java b/quickstep/src/com/android/quickstep/util/LauncherUnfoldAnimationController.java index 6d15e8be98..e0b527268c 100644 --- a/quickstep/src/com/android/quickstep/util/LauncherUnfoldAnimationController.java +++ b/quickstep/src/com/android/quickstep/util/LauncherUnfoldAnimationController.java @@ -60,6 +60,8 @@ public class LauncherUnfoldAnimationController implements OnDeviceProfileChangeL private final NaturalRotationUnfoldProgressProvider mNaturalOrientationProgressProvider; private final UnfoldMoveFromCenterHotseatAnimator mUnfoldMoveFromCenterHotseatAnimator; private final UnfoldMoveFromCenterWorkspaceAnimator mUnfoldMoveFromCenterWorkspaceAnimator; + private final TransitionStatusProvider mExternalTransitionStatusProvider = + new TransitionStatusProvider(); private PreemptiveUnfoldTransitionProgressProvider mPreemptiveProgressProvider = null; private Boolean mIsTablet = null; @@ -88,6 +90,8 @@ public class LauncherUnfoldAnimationController implements OnDeviceProfileChangeL unfoldTransitionProgressProvider); } + unfoldTransitionProgressProvider.addCallback(mExternalTransitionStatusProvider); + mUnfoldMoveFromCenterHotseatAnimator = new UnfoldMoveFromCenterHotseatAnimator(launcher, windowManager, rotationChangeProvider); mUnfoldMoveFromCenterWorkspaceAnimator = new UnfoldMoveFromCenterWorkspaceAnimator(launcher, @@ -166,11 +170,26 @@ public class LauncherUnfoldAnimationController implements OnDeviceProfileChangeL } if (mIsTablet != null && dp.isTablet != mIsTablet) { - if (dp.isTablet && SystemUiProxy.INSTANCE.get(mLauncher).isActive()) { + // We should preemptively start the animation only if: + // - We changed to the unfolded screen + // - SystemUI IPC connection is alive, so we won't end up in a situation that we won't + // receive transition progress events from SystemUI later because there was no + // IPC connection established (e.g. because of SystemUI crash) + // - SystemUI has not already sent unfold animation progress events. This might happen + // if Launcher was not open during unfold, in this case we receive the configuration + // change only after we went back to home screen and we don't want to start the + // animation in this case. + if (dp.isTablet + && SystemUiProxy.INSTANCE.get(mLauncher).isActive() + && !mExternalTransitionStatusProvider.hasRun()) { // Preemptively start the unfold animation to make sure that we have drawn // the first frame of the animation before the screen gets unblocked preemptivelyStartAnimationOnNextFrame(); } + + if (!dp.isTablet) { + mExternalTransitionStatusProvider.onFolded(); + } } mIsTablet = dp.isTablet; @@ -222,4 +241,48 @@ public class LauncherUnfoldAnimationController implements OnDeviceProfileChangeL HOTSEAT_SCALE_PROPERTY.setValue(mLauncher.getHotseat(), value); } } + + /** + * Class to track the current status of the external transition provider (the events are coming + * from the SystemUI side through IPC), it allows to check if the transition has already + * finished or currently running on the SystemUI side since last unfold. + */ + private static class TransitionStatusProvider implements TransitionProgressListener { + + private boolean mHasRun = false; + + @Override + public void onTransitionStarted() { + markAsRun(); + } + + @Override + public void onTransitionProgress(float progress) { + markAsRun(); + } + + @Override + public void onTransitionFinished() { + markAsRun(); + } + + /** + * Called when the device is folded, so we can reset the status of the animation + */ + public void onFolded() { + mHasRun = false; + } + + /** + * Returns true if there was an animation already (or it is currently running) after + * unfolding the device + */ + public boolean hasRun() { + return mHasRun; + } + + private void markAsRun() { + mHasRun = true; + } + } } diff --git a/src/com/android/launcher3/config/FeatureFlags.java b/src/com/android/launcher3/config/FeatureFlags.java index f5f6769c33..d0c31ece36 100644 --- a/src/com/android/launcher3/config/FeatureFlags.java +++ b/src/com/android/launcher3/config/FeatureFlags.java @@ -302,7 +302,7 @@ public final class FeatureFlags { "Enable widget transition animation when resizing the widgets"); public static final BooleanFlag PREEMPTIVE_UNFOLD_ANIMATION_START = getDebugFlag(270397209, - "PREEMPTIVE_UNFOLD_ANIMATION_START", DISABLED, + "PREEMPTIVE_UNFOLD_ANIMATION_START", ENABLED, "Enables starting the unfold animation preemptively when unfolding, without" + "waiting for SystemUI and then merging the SystemUI progress whenever we " + "start receiving the events");