From a707bb95257ca992f7cf3515d7acd650c2770749 Mon Sep 17 00:00:00 2001 From: Vlad Popa Date: Mon, 22 Aug 2022 14:32:23 +0000 Subject: [PATCH 1/2] Revert "Remove flag for keyguard remote animations [2/n]" Revert submission 19658837 Reason for revert: DroidMonitor-triggered revert due to breakage b/243379321 Reverted Changes: I2f672fb6d:Remove flag for keyguard remote animations [1/n] Ib103172b7:Remove flag for keyguard remote animations [2/n] Bug: 243379321 Change-Id: I23c682d6a90791f4379aef50b1b7a6126d41bee2 --- .../server/policy/PhoneWindowManager.java | 34 ++++++++++++------ .../server/policy/WindowManagerPolicy.java | 5 +-- .../keyguard/KeyguardServiceDelegate.java | 10 +++--- .../com/android/server/wm/AppTransition.java | 11 ++++-- .../server/wm/AppTransitionController.java | 30 ++++++++++++++++ .../com/android/server/wm/DisplayPolicy.java | 5 +-- .../server/wm/RecentsAnimationController.java | 3 +- .../com/android/server/wm/Transition.java | 35 +++++++++++++++++++ .../server/wm/TransitionController.java | 4 ++- .../server/wm/WindowManagerInternal.java | 7 ++-- .../server/wm/WindowManagerService.java | 26 ++++++++++++++ .../wm/RecentsAnimationControllerTest.java | 2 +- .../server/wm/TestWindowManagerPolicy.java | 2 +- 13 files changed, 146 insertions(+), 28 deletions(-) diff --git a/services/core/java/com/android/server/policy/PhoneWindowManager.java b/services/core/java/com/android/server/policy/PhoneWindowManager.java index 1b46d4433e8cb..b1eeef2c26c81 100644 --- a/services/core/java/com/android/server/policy/PhoneWindowManager.java +++ b/services/core/java/com/android/server/policy/PhoneWindowManager.java @@ -2082,10 +2082,20 @@ public class PhoneWindowManager implements WindowManagerPolicy { mWindowManagerInternal.registerAppTransitionListener(new AppTransitionListener() { @Override - public int onAppTransitionStartingLocked(long statusBarAnimationStartTime, + public int onAppTransitionStartingLocked(boolean keyguardGoingAway, + boolean keyguardOccluding, long duration, long statusBarAnimationStartTime, long statusBarAnimationDuration) { - return handleTransitionForKeyguardLw(false /* startKeyguardExitAnimation */, - false /* notifyOccluded */); + // When remote animation is enabled for keyguard transition, SysUI receives + // IRemoteAnimationRunner#onAnimationStart to start animation, so we don't + // need to call IKeyguardService#keyguardGoingAway and #setOccluded. + final boolean notifyOccluded = + !WindowManagerService.sEnableRemoteKeyguardOccludeAnimation + && keyguardOccluding; + final boolean startKeyguardExitAnimation = + !WindowManagerService.sEnableRemoteKeyguardGoingAwayAnimation + && keyguardGoingAway; + return handleTransitionForKeyguardLw(startKeyguardExitAnimation, + notifyOccluded, duration); } @Override @@ -2096,7 +2106,7 @@ public class PhoneWindowManager implements WindowManagerPolicy { // WindowManagerService and SysUI. handleTransitionForKeyguardLw( keyguardGoingAwayCancelled /* startKeyguardExitAnimation */, - keyguardOccludedCancelled /* notifyOccluded */); + keyguardOccludedCancelled /* notifyOccluded */, 0 /* duration */); } }); @@ -3285,16 +3295,17 @@ public class PhoneWindowManager implements WindowManagerPolicy { * start keyguard exit animation. * @param notifyOccluded Trigger IKeyguardService#setOccluded binder call to notify whether * the top activity can occlude the keyguard or not. + * @param duration the duration of the exit animation, in milliseconds. * * @return Whether the flags have changed and we have to redo the layout. */ private int handleTransitionForKeyguardLw(boolean startKeyguardExitAnimation, - boolean notifyOccluded) { + boolean notifyOccluded, long duration) { final int redoLayout = applyKeyguardOcclusionChange(notifyOccluded); if (redoLayout != 0) return redoLayout; if (startKeyguardExitAnimation) { if (DEBUG_KEYGUARD) Slog.d(TAG, "Starting keyguard exit animation"); - startKeyguardExitAnimation(SystemClock.uptimeMillis()); + startKeyguardExitAnimation(SystemClock.uptimeMillis(), duration); } return 0; } @@ -3536,8 +3547,11 @@ public class PhoneWindowManager implements WindowManagerPolicy { if (isKeyguardOccluded() == isOccluded) { return false; } - mKeyguardDelegate.setOccluded(isOccluded, notify); - return mKeyguardDelegate.isShowing(); + + final boolean showing = mKeyguardDelegate.isShowing(); + final boolean animate = showing && !isOccluded; + mKeyguardDelegate.setOccluded(isOccluded, animate, notify); + return showing; } /** {@inheritDoc} */ @@ -4933,10 +4947,10 @@ public class PhoneWindowManager implements WindowManagerPolicy { } @Override - public void startKeyguardExitAnimation(long startTime) { + public void startKeyguardExitAnimation(long startTime, long fadeoutDuration) { if (mKeyguardDelegate != null) { if (DEBUG_KEYGUARD) Slog.d(TAG, "PWM.startKeyguardExitAnimation"); - mKeyguardDelegate.startKeyguardExitAnimation(startTime); + mKeyguardDelegate.startKeyguardExitAnimation(startTime, fadeoutDuration); } } diff --git a/services/core/java/com/android/server/policy/WindowManagerPolicy.java b/services/core/java/com/android/server/policy/WindowManagerPolicy.java index 6fcdb7de52be2..c4713efa89268 100644 --- a/services/core/java/com/android/server/policy/WindowManagerPolicy.java +++ b/services/core/java/com/android/server/policy/WindowManagerPolicy.java @@ -1129,10 +1129,11 @@ public interface WindowManagerPolicy extends WindowManagerPolicyConstants { /** * Notifies the keyguard to start fading out. - * @param startTime the start time of the animation in uptime milliseconds * + * @param startTime the start time of the animation in uptime milliseconds + * @param fadeoutDuration the duration of the exit animation, in milliseconds */ - void startKeyguardExitAnimation(long startTime); + void startKeyguardExitAnimation(long startTime, long fadeoutDuration); /** * Called when System UI has been started. diff --git a/services/core/java/com/android/server/policy/keyguard/KeyguardServiceDelegate.java b/services/core/java/com/android/server/policy/keyguard/KeyguardServiceDelegate.java index 7737421654ee2..b79ac6f68be20 100644 --- a/services/core/java/com/android/server/policy/keyguard/KeyguardServiceDelegate.java +++ b/services/core/java/com/android/server/policy/keyguard/KeyguardServiceDelegate.java @@ -249,10 +249,10 @@ public class KeyguardServiceDelegate { } } - public void setOccluded(boolean isOccluded, boolean notify) { + public void setOccluded(boolean isOccluded, boolean animate, boolean notify) { if (mKeyguardService != null && notify) { - if (DEBUG) Log.v(TAG, "setOccluded(" + isOccluded + ")"); - mKeyguardService.setOccluded(isOccluded, false /* animate */); + if (DEBUG) Log.v(TAG, "setOccluded(" + isOccluded + ") animate=" + animate); + mKeyguardService.setOccluded(isOccluded, animate); } mKeyguardState.occluded = isOccluded; } @@ -394,9 +394,9 @@ public class KeyguardServiceDelegate { } } - public void startKeyguardExitAnimation(long startTime) { + public void startKeyguardExitAnimation(long startTime, long fadeoutDuration) { if (mKeyguardService != null) { - mKeyguardService.startKeyguardExitAnimation(startTime, 0); + mKeyguardService.startKeyguardExitAnimation(startTime, fadeoutDuration); } } diff --git a/services/core/java/com/android/server/wm/AppTransition.java b/services/core/java/com/android/server/wm/AppTransition.java index 95169dbd70920..efffd62a5ed0f 100644 --- a/services/core/java/com/android/server/wm/AppTransition.java +++ b/services/core/java/com/android/server/wm/AppTransition.java @@ -375,6 +375,9 @@ public class AppTransition implements Dump { final AnimationAdapter topOpeningAnim = wc != null ? wc.getAnimation() : null; int redoLayout = notifyAppTransitionStartingLocked( + AppTransition.isKeyguardGoingAwayTransitOld(transit), + AppTransition.isKeyguardOccludeTransitOld(transit), + topOpeningAnim != null ? topOpeningAnim.getDurationHint() : 0, topOpeningAnim != null ? topOpeningAnim.getStatusBarTransitionsStartTime() : SystemClock.uptimeMillis(), @@ -493,12 +496,14 @@ public class AppTransition implements Dump { } } - private int notifyAppTransitionStartingLocked(long statusBarAnimationStartTime, + private int notifyAppTransitionStartingLocked(boolean keyguardGoingAway, + boolean keyguardOcclude, long duration, long statusBarAnimationStartTime, long statusBarAnimationDuration) { int redoLayout = 0; for (int i = 0; i < mListeners.size(); i++) { - redoLayout |= mListeners.get(i).onAppTransitionStartingLocked( - statusBarAnimationStartTime, statusBarAnimationDuration); + redoLayout |= mListeners.get(i).onAppTransitionStartingLocked(keyguardGoingAway, + keyguardOcclude, duration, statusBarAnimationStartTime, + statusBarAnimationDuration); } return redoLayout; } diff --git a/services/core/java/com/android/server/wm/AppTransitionController.java b/services/core/java/com/android/server/wm/AppTransitionController.java index a645e89d700b7..963345f2f49f2 100644 --- a/services/core/java/com/android/server/wm/AppTransitionController.java +++ b/services/core/java/com/android/server/wm/AppTransitionController.java @@ -20,6 +20,10 @@ import static android.app.WindowConfiguration.ACTIVITY_TYPE_DREAM; import static android.view.WindowManager.TRANSIT_CHANGE; import static android.view.WindowManager.TRANSIT_CLOSE; import static android.view.WindowManager.TRANSIT_FLAG_APP_CRASHED; +import static android.view.WindowManager.TRANSIT_FLAG_KEYGUARD_GOING_AWAY_NO_ANIMATION; +import static android.view.WindowManager.TRANSIT_FLAG_KEYGUARD_GOING_AWAY_SUBTLE_ANIMATION; +import static android.view.WindowManager.TRANSIT_FLAG_KEYGUARD_GOING_AWAY_TO_SHADE; +import static android.view.WindowManager.TRANSIT_FLAG_KEYGUARD_GOING_AWAY_WITH_WALLPAPER; import static android.view.WindowManager.TRANSIT_FLAG_OPEN_BEHIND; import static android.view.WindowManager.TRANSIT_KEYGUARD_GOING_AWAY; import static android.view.WindowManager.TRANSIT_KEYGUARD_OCCLUDE; @@ -89,6 +93,7 @@ import android.view.WindowManager.LayoutParams; import android.view.WindowManager.TransitionFlags; import android.view.WindowManager.TransitionOldType; import android.view.WindowManager.TransitionType; +import android.view.animation.Animation; import android.window.ITaskFragmentOrganizer; import com.android.internal.annotations.VisibleForTesting; @@ -290,6 +295,7 @@ public class AppTransitionController { final int flags = appTransition.getTransitFlags(); layoutRedo = appTransition.goodToGo(transit, topOpeningApp); + handleNonAppWindowsInTransition(transit, flags); appTransition.postAnimationCallback(); appTransition.clear(); } finally { @@ -1137,6 +1143,30 @@ public class AppTransitionController { } } + private void handleNonAppWindowsInTransition(@TransitionOldType int transit, int flags) { + if (transit == TRANSIT_OLD_KEYGUARD_GOING_AWAY + && !WindowManagerService.sEnableRemoteKeyguardGoingAwayAnimation) { + if ((flags & TRANSIT_FLAG_KEYGUARD_GOING_AWAY_WITH_WALLPAPER) != 0 + && (flags & TRANSIT_FLAG_KEYGUARD_GOING_AWAY_NO_ANIMATION) == 0 + && (flags & TRANSIT_FLAG_KEYGUARD_GOING_AWAY_SUBTLE_ANIMATION) == 0) { + Animation anim = mService.mPolicy.createKeyguardWallpaperExit( + (flags & TRANSIT_FLAG_KEYGUARD_GOING_AWAY_TO_SHADE) != 0); + if (anim != null) { + anim.scaleCurrentDuration(mService.getTransitionAnimationScaleLocked()); + mDisplayContent.mWallpaperController.startWallpaperAnimation(anim); + } + } + } + if ((transit == TRANSIT_OLD_KEYGUARD_GOING_AWAY + || transit == TRANSIT_OLD_KEYGUARD_GOING_AWAY_ON_WALLPAPER) + && !WindowManagerService.sEnableRemoteKeyguardGoingAwayAnimation) { + mDisplayContent.startKeyguardExitOnNonAppWindows( + transit == TRANSIT_OLD_KEYGUARD_GOING_AWAY_ON_WALLPAPER, + (flags & TRANSIT_FLAG_KEYGUARD_GOING_AWAY_TO_SHADE) != 0, + (flags & TRANSIT_FLAG_KEYGUARD_GOING_AWAY_SUBTLE_ANIMATION) != 0); + } + } + private boolean transitionGoodToGo(ArraySet apps, ArrayMap outReasons) { ProtoLog.v(WM_DEBUG_APP_TRANSITIONS, diff --git a/services/core/java/com/android/server/wm/DisplayPolicy.java b/services/core/java/com/android/server/wm/DisplayPolicy.java index 785add4565696..23b03e06e18a2 100644 --- a/services/core/java/com/android/server/wm/DisplayPolicy.java +++ b/services/core/java/com/android/server/wm/DisplayPolicy.java @@ -602,8 +602,9 @@ public class DisplayPolicy { } @Override - public int onAppTransitionStartingLocked(long statusBarAnimationStartTime, - long statusBarAnimationDuration) { + public int onAppTransitionStartingLocked(boolean keyguardGoingAway, + boolean keyguardOccluding, long duration, + long statusBarAnimationStartTime, long statusBarAnimationDuration) { mHandler.post(() -> { StatusBarManagerInternal statusBar = getStatusBarManagerInternal(); if (statusBar != null) { diff --git a/services/core/java/com/android/server/wm/RecentsAnimationController.java b/services/core/java/com/android/server/wm/RecentsAnimationController.java index db79eae1d80c5..1404f2f497672 100644 --- a/services/core/java/com/android/server/wm/RecentsAnimationController.java +++ b/services/core/java/com/android/server/wm/RecentsAnimationController.java @@ -161,7 +161,8 @@ public class RecentsAnimationController implements DeathRecipient { */ final AppTransitionListener mAppTransitionListener = new AppTransitionListener() { @Override - public int onAppTransitionStartingLocked(long statusBarAnimationStartTime, + public int onAppTransitionStartingLocked(boolean keyguardGoingAway, + boolean keyguardOccluding, long duration, long statusBarAnimationStartTime, long statusBarAnimationDuration) { continueDeferredCancel(); return 0; diff --git a/services/core/java/com/android/server/wm/Transition.java b/services/core/java/com/android/server/wm/Transition.java index e9e96809195c2..6ee9999f77e2d 100644 --- a/services/core/java/com/android/server/wm/Transition.java +++ b/services/core/java/com/android/server/wm/Transition.java @@ -31,7 +31,13 @@ import static android.view.WindowManager.LayoutParams.TYPE_INPUT_METHOD; import static android.view.WindowManager.TRANSIT_CHANGE; import static android.view.WindowManager.TRANSIT_CLOSE; import static android.view.WindowManager.TRANSIT_FLAG_IS_RECENTS; +import static android.view.WindowManager.TRANSIT_FLAG_KEYGUARD_GOING_AWAY; +import static android.view.WindowManager.TRANSIT_FLAG_KEYGUARD_GOING_AWAY_NO_ANIMATION; +import static android.view.WindowManager.TRANSIT_FLAG_KEYGUARD_GOING_AWAY_SUBTLE_ANIMATION; +import static android.view.WindowManager.TRANSIT_FLAG_KEYGUARD_GOING_AWAY_TO_SHADE; +import static android.view.WindowManager.TRANSIT_FLAG_KEYGUARD_GOING_AWAY_WITH_WALLPAPER; import static android.view.WindowManager.TRANSIT_FLAG_KEYGUARD_LOCKED; +import static android.view.WindowManager.TRANSIT_KEYGUARD_GOING_AWAY; import static android.view.WindowManager.TRANSIT_OPEN; import static android.view.WindowManager.TRANSIT_TO_BACK; import static android.view.WindowManager.TRANSIT_TO_FRONT; @@ -66,6 +72,7 @@ import android.os.Binder; import android.os.IBinder; import android.os.IRemoteCallback; import android.os.RemoteException; +import android.os.SystemClock; import android.os.Trace; import android.util.ArrayMap; import android.util.ArraySet; @@ -73,6 +80,7 @@ import android.util.Slog; import android.util.SparseArray; import android.view.SurfaceControl; import android.view.WindowManager; +import android.view.animation.Animation; import android.window.RemoteTransition; import android.window.TransitionInfo; @@ -1045,6 +1053,33 @@ class Transition extends Binder implements BLASTSyncEngine.TransactionReadyListe private void handleNonAppWindowsInTransition(@NonNull DisplayContent dc, @TransitionType int transit, @TransitionFlags int flags) { + if ((transit == TRANSIT_KEYGUARD_GOING_AWAY + || (flags & TRANSIT_FLAG_KEYGUARD_GOING_AWAY) != 0) + && !WindowManagerService.sEnableRemoteKeyguardGoingAwayAnimation) { + if ((flags & TRANSIT_FLAG_KEYGUARD_GOING_AWAY_WITH_WALLPAPER) != 0 + && (flags & TRANSIT_FLAG_KEYGUARD_GOING_AWAY_NO_ANIMATION) == 0 + && (flags & TRANSIT_FLAG_KEYGUARD_GOING_AWAY_SUBTLE_ANIMATION) == 0) { + Animation anim = mController.mAtm.mWindowManager.mPolicy + .createKeyguardWallpaperExit( + (flags & TRANSIT_FLAG_KEYGUARD_GOING_AWAY_TO_SHADE) != 0); + if (anim != null) { + anim.scaleCurrentDuration( + mController.mAtm.mWindowManager.getTransitionAnimationScaleLocked()); + dc.mWallpaperController.startWallpaperAnimation(anim); + } + } + dc.startKeyguardExitOnNonAppWindows( + (flags & TRANSIT_FLAG_KEYGUARD_GOING_AWAY_WITH_WALLPAPER) != 0, + (flags & TRANSIT_FLAG_KEYGUARD_GOING_AWAY_TO_SHADE) != 0, + (flags & TRANSIT_FLAG_KEYGUARD_GOING_AWAY_SUBTLE_ANIMATION) != 0); + if (!WindowManagerService.sEnableRemoteKeyguardGoingAwayAnimation) { + // When remote animation is enabled for KEYGUARD_GOING_AWAY transition, SysUI + // receives IRemoteAnimationRunner#onAnimationStart to start animation, so we don't + // need to call IKeyguardService#keyguardGoingAway here. + mController.mAtm.mWindowManager.mPolicy.startKeyguardExitAnimation( + SystemClock.uptimeMillis(), 0 /* duration */); + } + } if ((flags & TRANSIT_FLAG_KEYGUARD_LOCKED) != 0) { mController.mAtm.mWindowManager.mPolicy.applyKeyguardOcclusionChange( false /* notify */); diff --git a/services/core/java/com/android/server/wm/TransitionController.java b/services/core/java/com/android/server/wm/TransitionController.java index 79dfaa961bf28..3c6d6dcae60e3 100644 --- a/services/core/java/com/android/server/wm/TransitionController.java +++ b/services/core/java/com/android/server/wm/TransitionController.java @@ -638,9 +638,11 @@ class TransitionController { } void dispatchLegacyAppTransitionStarting(TransitionInfo info, long statusBarTransitionDelay) { + final boolean keyguardGoingAway = info.isKeyguardGoingAway(); for (int i = 0; i < mLegacyListeners.size(); ++i) { // TODO(shell-transitions): handle (un)occlude transition. - mLegacyListeners.get(i).onAppTransitionStartingLocked( + mLegacyListeners.get(i).onAppTransitionStartingLocked(keyguardGoingAway, + false /* keyguardOcclude */, 0 /* durationHint */, SystemClock.uptimeMillis() + statusBarTransitionDelay, AnimationAdapter.STATUS_BAR_TRANSITION_DURATION); } diff --git a/services/core/java/com/android/server/wm/WindowManagerInternal.java b/services/core/java/com/android/server/wm/WindowManagerInternal.java index 822eb9cb994cb..a3245e0a1a5c3 100644 --- a/services/core/java/com/android/server/wm/WindowManagerInternal.java +++ b/services/core/java/com/android/server/wm/WindowManagerInternal.java @@ -219,7 +219,6 @@ public abstract class WindowManagerInternal { /** * Called when a pending app transition gets cancelled. - * * @param keyguardGoingAwayCancelled {@code true} if keyguard going away transition was * cancelled. * @param keyguardOccludedCancelled {@code true} if keyguard (un)occluded transition was @@ -236,6 +235,9 @@ public abstract class WindowManagerInternal { /** * Called when an app transition gets started * + * @param keyguardGoingAway true if keyguard going away transition is started. + * @param keyguardOccluding true if keyguard (un)occlude transition is started. + * @param duration the total duration of the transition * @param statusBarAnimationStartTime the desired start time for all visual animations in * the status bar caused by this app transition in uptime millis * @param statusBarAnimationDuration the duration for all visual animations in the status @@ -246,7 +248,8 @@ public abstract class WindowManagerInternal { * {@link WindowManagerPolicy#FINISH_LAYOUT_REDO_WALLPAPER}, * or {@link WindowManagerPolicy#FINISH_LAYOUT_REDO_ANIM}. */ - public int onAppTransitionStartingLocked(long statusBarAnimationStartTime, + public int onAppTransitionStartingLocked(boolean keyguardGoingAway, + boolean keyguardOccluding, long duration, long statusBarAnimationStartTime, long statusBarAnimationDuration) { return 0; } diff --git a/services/core/java/com/android/server/wm/WindowManagerService.java b/services/core/java/com/android/server/wm/WindowManagerService.java index 648ed250ecf30..31adbc2028dff 100644 --- a/services/core/java/com/android/server/wm/WindowManagerService.java +++ b/services/core/java/com/android/server/wm/WindowManagerService.java @@ -423,6 +423,32 @@ public class WindowManagerService extends IWindowManager.Stub public static final boolean sEnableShellTransitions = SystemProperties.getBoolean(ENABLE_SHELL_TRANSITIONS, false); + /** + * Run Keyguard animation as remote animation in System UI instead of local animation in + * the server process. + * + * 0: Runs all keyguard animation as local animation + * 1: Only runs keyguard going away animation as remote animation + * 2: Runs all keyguard animation as remote animation + */ + private static final String ENABLE_REMOTE_KEYGUARD_ANIMATION_PROPERTY = + "persist.wm.enable_remote_keyguard_animation"; + + private static final int sEnableRemoteKeyguardAnimation = + SystemProperties.getInt(ENABLE_REMOTE_KEYGUARD_ANIMATION_PROPERTY, 2); + + /** + * @see #ENABLE_REMOTE_KEYGUARD_ANIMATION_PROPERTY + */ + public static final boolean sEnableRemoteKeyguardGoingAwayAnimation = + sEnableRemoteKeyguardAnimation >= 1; + + /** + * @see #ENABLE_REMOTE_KEYGUARD_ANIMATION_PROPERTY + */ + public static final boolean sEnableRemoteKeyguardOccludeAnimation = + sEnableRemoteKeyguardAnimation >= 2; + /** * Allows a fullscreen windowing mode activity to launch in its desired orientation directly * when the display has different orientation. 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 88e58eab58aa1..8546763aebecf 100644 --- a/services/tests/wmtests/src/com/android/server/wm/RecentsAnimationControllerTest.java +++ b/services/tests/wmtests/src/com/android/server/wm/RecentsAnimationControllerTest.java @@ -281,7 +281,7 @@ public class RecentsAnimationControllerTest extends WindowTestsBase { verify(mMockRunner).onAnimationCanceled(null /* taskIds */, null /* taskSnapshots */); // Simulate the app transition finishing - mController.mAppTransitionListener.onAppTransitionStartingLocked(0, 0); + mController.mAppTransitionListener.onAppTransitionStartingLocked(false, false, 0, 0, 0); verify(mAnimationCallbacks).onAnimationFinished(REORDER_KEEP_IN_PLACE, false); } diff --git a/services/tests/wmtests/src/com/android/server/wm/TestWindowManagerPolicy.java b/services/tests/wmtests/src/com/android/server/wm/TestWindowManagerPolicy.java index 030af308a5200..2d921cfa20037 100644 --- a/services/tests/wmtests/src/com/android/server/wm/TestWindowManagerPolicy.java +++ b/services/tests/wmtests/src/com/android/server/wm/TestWindowManagerPolicy.java @@ -310,7 +310,7 @@ class TestWindowManagerPolicy implements WindowManagerPolicy { } @Override - public void startKeyguardExitAnimation(long startTime) { + public void startKeyguardExitAnimation(long startTime, long fadeoutDuration) { } @Override From 92b15a07b8c9fe847cd639355b49fbb83ba282f3 Mon Sep 17 00:00:00 2001 From: Vlad Popa Date: Mon, 22 Aug 2022 14:32:23 +0000 Subject: [PATCH 2/2] Revert "Remove flag for keyguard remote animations [1/n]" Revert submission 19658837 Reason for revert: DroidMonitor-triggered revert due to breakage b/243379321 Reverted Changes: I2f672fb6d:Remove flag for keyguard remote animations [1/n] Ib103172b7:Remove flag for keyguard remote animations [2/n] Bug: 243379321 Change-Id: Ia53ce4d2f5a76424a6143dfcbd913635a10761bc --- .../server/policy/PhoneWindowManager.java | 71 ++++++++----------- .../server/policy/WindowManagerPolicy.java | 6 +- .../com/android/server/wm/AppTransition.java | 13 ++-- .../com/android/server/wm/DisplayContent.java | 3 +- .../com/android/server/wm/DisplayPolicy.java | 3 +- .../server/wm/RecentsAnimationController.java | 3 +- .../com/android/server/wm/Transition.java | 2 +- .../server/wm/TransitionController.java | 2 +- .../server/wm/WindowManagerInternal.java | 9 +-- .../server/wm/WindowManagerService.java | 3 +- .../server/wm/TestWindowManagerPolicy.java | 2 +- 11 files changed, 47 insertions(+), 70 deletions(-) diff --git a/services/core/java/com/android/server/policy/PhoneWindowManager.java b/services/core/java/com/android/server/policy/PhoneWindowManager.java index b1eeef2c26c81..5816e984704eb 100644 --- a/services/core/java/com/android/server/policy/PhoneWindowManager.java +++ b/services/core/java/com/android/server/policy/PhoneWindowManager.java @@ -2085,28 +2085,19 @@ public class PhoneWindowManager implements WindowManagerPolicy { public int onAppTransitionStartingLocked(boolean keyguardGoingAway, boolean keyguardOccluding, long duration, long statusBarAnimationStartTime, long statusBarAnimationDuration) { - // When remote animation is enabled for keyguard transition, SysUI receives - // IRemoteAnimationRunner#onAnimationStart to start animation, so we don't - // need to call IKeyguardService#keyguardGoingAway and #setOccluded. - final boolean notifyOccluded = - !WindowManagerService.sEnableRemoteKeyguardOccludeAnimation - && keyguardOccluding; - final boolean startKeyguardExitAnimation = - !WindowManagerService.sEnableRemoteKeyguardGoingAwayAnimation - && keyguardGoingAway; - return handleTransitionForKeyguardLw(startKeyguardExitAnimation, - notifyOccluded, duration); + // When remote animation is enabled for KEYGUARD_GOING_AWAY transition, SysUI + // receives IRemoteAnimationRunner#onAnimationStart to start animation, so we don't + // need to call IKeyguardService#keyguardGoingAway here. + return handleStartTransitionForKeyguardLw(keyguardGoingAway + && !WindowManagerService.sEnableRemoteKeyguardGoingAwayAnimation, + keyguardOccluding, duration); } @Override - public void onAppTransitionCancelledLocked(boolean keyguardGoingAwayCancelled, - boolean keyguardOccludedCancelled) { - // When app KEYGUARD_GOING_AWAY or (UN)OCCLUDE app transition is canceled, we need - // to trigger relevant IKeyguardService calls to sync keyguard status in - // WindowManagerService and SysUI. - handleTransitionForKeyguardLw( - keyguardGoingAwayCancelled /* startKeyguardExitAnimation */, - keyguardOccludedCancelled /* notifyOccluded */, 0 /* duration */); + public void onAppTransitionCancelledLocked(boolean keyguardGoingAway) { + handleStartTransitionForKeyguardLw( + keyguardGoingAway, false /* keyguardOccludingStarted */, + 0 /* duration */); } }); @@ -3272,38 +3263,29 @@ public class PhoneWindowManager implements WindowManagerPolicy { mPendingKeyguardOccluded = occluded; mKeyguardOccludedChanged = true; } else { - setKeyguardOccludedLw(occluded, true /* notify */); + setKeyguardOccludedLw(occluded, false /* force */, + false /* transitionStarted */); } } @Override - public int applyKeyguardOcclusionChange(boolean notify) { + public int applyKeyguardOcclusionChange(boolean transitionStarted) { if (mKeyguardOccludedChanged) { if (DEBUG_KEYGUARD) Slog.d(TAG, "transition/occluded changed occluded=" + mPendingKeyguardOccluded); - if (setKeyguardOccludedLw(mPendingKeyguardOccluded, notify)) { + if (setKeyguardOccludedLw(mPendingKeyguardOccluded, false /* force */, + transitionStarted)) { return FINISH_LAYOUT_REDO_LAYOUT | FINISH_LAYOUT_REDO_WALLPAPER; } } return 0; } - /** - * Called when keyguard related app transition starts, or cancelled. - * - * @param startKeyguardExitAnimation Trigger IKeyguardService#startKeyguardExitAnimation to - * start keyguard exit animation. - * @param notifyOccluded Trigger IKeyguardService#setOccluded binder call to notify whether - * the top activity can occlude the keyguard or not. - * @param duration the duration of the exit animation, in milliseconds. - * - * @return Whether the flags have changed and we have to redo the layout. - */ - private int handleTransitionForKeyguardLw(boolean startKeyguardExitAnimation, - boolean notifyOccluded, long duration) { - final int redoLayout = applyKeyguardOcclusionChange(notifyOccluded); + private int handleStartTransitionForKeyguardLw(boolean keyguardGoingAway, + boolean keyguardOccluding, long duration) { + final int redoLayout = applyKeyguardOcclusionChange(keyguardOccluding); if (redoLayout != 0) return redoLayout; - if (startKeyguardExitAnimation) { + if (keyguardGoingAway) { if (DEBUG_KEYGUARD) Slog.d(TAG, "Starting keyguard exit animation"); startKeyguardExitAnimation(SystemClock.uptimeMillis(), duration); } @@ -3537,19 +3519,26 @@ public class PhoneWindowManager implements WindowManagerPolicy { * Updates the occluded state of the Keyguard. * * @param isOccluded Whether the Keyguard is occluded by another window. - * @param notify Notify keyguard occlude status change immediately via - * {@link com.android.internal.policy.IKeyguardService}. + * @param force notify the occluded status to KeyguardService and update flags even though + * occlude status doesn't change. + * @param transitionStarted {@code true} if keyguard (un)occluded transition started. * @return Whether the flags have changed and we have to redo the layout. */ - private boolean setKeyguardOccludedLw(boolean isOccluded, boolean notify) { + private boolean setKeyguardOccludedLw(boolean isOccluded, boolean force, + boolean transitionStarted) { if (DEBUG_KEYGUARD) Slog.d(TAG, "setKeyguardOccluded occluded=" + isOccluded); mKeyguardOccludedChanged = false; - if (isKeyguardOccluded() == isOccluded) { + if (isKeyguardOccluded() == isOccluded && !force) { return false; } final boolean showing = mKeyguardDelegate.isShowing(); final boolean animate = showing && !isOccluded; + // When remote animation is enabled for keyguard (un)occlude transition, KeyguardService + // uses remote animation start as a signal to update its occlusion status ,so we don't need + // to notify here. + final boolean notify = !WindowManagerService.sEnableRemoteKeyguardOccludeAnimation + || !transitionStarted; mKeyguardDelegate.setOccluded(isOccluded, animate, notify); return showing; } diff --git a/services/core/java/com/android/server/policy/WindowManagerPolicy.java b/services/core/java/com/android/server/policy/WindowManagerPolicy.java index c4713efa89268..e8a3dcd5635f2 100644 --- a/services/core/java/com/android/server/policy/WindowManagerPolicy.java +++ b/services/core/java/com/android/server/policy/WindowManagerPolicy.java @@ -171,10 +171,10 @@ public interface WindowManagerPolicy extends WindowManagerPolicyConstants { void onKeyguardOccludedChangedLw(boolean occluded); /** - * @param notify {@code true} if the status change should be immediately notified via - * {@link com.android.internal.policy.IKeyguardService} + * Applies a keyguard occlusion change if one happened. + * @param transitionStarted Whether keyguard (un)occlude transition is starting or not. */ - int applyKeyguardOcclusionChange(boolean notify); + int applyKeyguardOcclusionChange(boolean transitionStarted); /** * Interface to the Window Manager state associated with a particular diff --git a/services/core/java/com/android/server/wm/AppTransition.java b/services/core/java/com/android/server/wm/AppTransition.java index efffd62a5ed0f..55d6b2fe82269 100644 --- a/services/core/java/com/android/server/wm/AppTransition.java +++ b/services/core/java/com/android/server/wm/AppTransition.java @@ -416,11 +416,8 @@ public class AppTransition implements Dump { } void freeze() { - final boolean keyguardGoingAwayCancelled = mNextAppTransitionRequests.contains( + final boolean keyguardGoingAway = mNextAppTransitionRequests.contains( TRANSIT_KEYGUARD_GOING_AWAY); - final boolean keyguardOccludedCancelled = - mNextAppTransitionRequests.contains(TRANSIT_KEYGUARD_OCCLUDE) - || mNextAppTransitionRequests.contains(TRANSIT_KEYGUARD_UNOCCLUDE); // The RemoteAnimationControl didn't register AppTransitionListener and // only initialized the finish and timeout callback when goodToGo(). @@ -432,7 +429,7 @@ public class AppTransition implements Dump { mNextAppTransitionRequests.clear(); clear(); setReady(); - notifyAppTransitionCancelledLocked(keyguardGoingAwayCancelled, keyguardOccludedCancelled); + notifyAppTransitionCancelledLocked(keyguardGoingAway); } private void setAppTransitionState(int state) { @@ -482,11 +479,9 @@ public class AppTransition implements Dump { } } - private void notifyAppTransitionCancelledLocked(boolean keyguardGoingAwayCancelled, - boolean keyguardOccludedCancelled) { + private void notifyAppTransitionCancelledLocked(boolean keyguardGoingAway) { for (int i = 0; i < mListeners.size(); i++) { - mListeners.get(i).onAppTransitionCancelledLocked(keyguardGoingAwayCancelled, - keyguardOccludedCancelled); + mListeners.get(i).onAppTransitionCancelledLocked(keyguardGoingAway); } } diff --git a/services/core/java/com/android/server/wm/DisplayContent.java b/services/core/java/com/android/server/wm/DisplayContent.java index 767df6d60b3b9..fccf54d831981 100644 --- a/services/core/java/com/android/server/wm/DisplayContent.java +++ b/services/core/java/com/android/server/wm/DisplayContent.java @@ -6602,8 +6602,7 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp } @Override - public void onAppTransitionCancelledLocked(boolean keyguardGoingAwayCancelled, - boolean keyguardOccludedCancelled) { + public void onAppTransitionCancelledLocked(boolean keyguardGoingAway) { // It is only needed when freezing display in legacy transition. if (mTransitionController.isShellTransitionsEnabled()) return; continueUpdateOrientationForDiffOrienLaunchingApp(); diff --git a/services/core/java/com/android/server/wm/DisplayPolicy.java b/services/core/java/com/android/server/wm/DisplayPolicy.java index 23b03e06e18a2..07694065cbd79 100644 --- a/services/core/java/com/android/server/wm/DisplayPolicy.java +++ b/services/core/java/com/android/server/wm/DisplayPolicy.java @@ -616,8 +616,7 @@ public class DisplayPolicy { } @Override - public void onAppTransitionCancelledLocked(boolean keyguardGoingAwayCancelled, - boolean keyguardOccludedCancelled) { + public void onAppTransitionCancelledLocked(boolean keyguardGoingAway) { mHandler.post(mAppTransitionCancelled); } diff --git a/services/core/java/com/android/server/wm/RecentsAnimationController.java b/services/core/java/com/android/server/wm/RecentsAnimationController.java index 1404f2f497672..5b702eac70590 100644 --- a/services/core/java/com/android/server/wm/RecentsAnimationController.java +++ b/services/core/java/com/android/server/wm/RecentsAnimationController.java @@ -169,8 +169,7 @@ public class RecentsAnimationController implements DeathRecipient { } @Override - public void onAppTransitionCancelledLocked(boolean keyguardGoingAwayCancelled, - boolean keyguardOccludedCancelled) { + public void onAppTransitionCancelledLocked(boolean keyguardGoingAway) { continueDeferredCancel(); } diff --git a/services/core/java/com/android/server/wm/Transition.java b/services/core/java/com/android/server/wm/Transition.java index 6ee9999f77e2d..bbc95a1dd70f6 100644 --- a/services/core/java/com/android/server/wm/Transition.java +++ b/services/core/java/com/android/server/wm/Transition.java @@ -1082,7 +1082,7 @@ class Transition extends Binder implements BLASTSyncEngine.TransactionReadyListe } if ((flags & TRANSIT_FLAG_KEYGUARD_LOCKED) != 0) { mController.mAtm.mWindowManager.mPolicy.applyKeyguardOcclusionChange( - false /* notify */); + true /* keyguardOccludingStarted */); } } diff --git a/services/core/java/com/android/server/wm/TransitionController.java b/services/core/java/com/android/server/wm/TransitionController.java index 3c6d6dcae60e3..4f324f22aa5ea 100644 --- a/services/core/java/com/android/server/wm/TransitionController.java +++ b/services/core/java/com/android/server/wm/TransitionController.java @@ -657,7 +657,7 @@ class TransitionController { void dispatchLegacyAppTransitionCancelled() { for (int i = 0; i < mLegacyListeners.size(); ++i) { mLegacyListeners.get(i).onAppTransitionCancelledLocked( - false /* keyguardGoingAwayCancelled */, false /* keyguardOccludedCancelled */); + false /* keyguardGoingAway */); } } diff --git a/services/core/java/com/android/server/wm/WindowManagerInternal.java b/services/core/java/com/android/server/wm/WindowManagerInternal.java index a3245e0a1a5c3..da5f5d0e29fdc 100644 --- a/services/core/java/com/android/server/wm/WindowManagerInternal.java +++ b/services/core/java/com/android/server/wm/WindowManagerInternal.java @@ -219,13 +219,10 @@ public abstract class WindowManagerInternal { /** * Called when a pending app transition gets cancelled. - * @param keyguardGoingAwayCancelled {@code true} if keyguard going away transition was - * cancelled. - * @param keyguardOccludedCancelled {@code true} if keyguard (un)occluded transition was - * cancelled. + * + * @param keyguardGoingAway true if keyguard going away transition got cancelled. */ - public void onAppTransitionCancelledLocked(boolean keyguardGoingAwayCancelled, - boolean keyguardOccludedCancelled) {} + public void onAppTransitionCancelledLocked(boolean keyguardGoingAway) {} /** * Called when an app transition is timed out. diff --git a/services/core/java/com/android/server/wm/WindowManagerService.java b/services/core/java/com/android/server/wm/WindowManagerService.java index 31adbc2028dff..fd54f78b22fef 100644 --- a/services/core/java/com/android/server/wm/WindowManagerService.java +++ b/services/core/java/com/android/server/wm/WindowManagerService.java @@ -1117,8 +1117,7 @@ public class WindowManagerService extends IWindowManager.Stub = new WindowManagerInternal.AppTransitionListener() { @Override - public void onAppTransitionCancelledLocked(boolean keyguardGoingAwayCancelled, - boolean keyguardOccludedCancelled) { + public void onAppTransitionCancelledLocked(boolean keyguardGoingAway) { } @Override diff --git a/services/tests/wmtests/src/com/android/server/wm/TestWindowManagerPolicy.java b/services/tests/wmtests/src/com/android/server/wm/TestWindowManagerPolicy.java index 2d921cfa20037..851be9d77348e 100644 --- a/services/tests/wmtests/src/com/android/server/wm/TestWindowManagerPolicy.java +++ b/services/tests/wmtests/src/com/android/server/wm/TestWindowManagerPolicy.java @@ -314,7 +314,7 @@ class TestWindowManagerPolicy implements WindowManagerPolicy { } @Override - public int applyKeyguardOcclusionChange(boolean notify) { + public int applyKeyguardOcclusionChange(boolean keyguardOccludingStarted) { return 0; }