Merge "Fix bouncer to launcher/app animation" into sc-dev

packages/SystemUI/plugin/src/com/android/systemui/plugins/ActivityStarter.java

@@ -92,5 +92,12 @@ public interface ActivityStarter {
          *         *after* returning to start hiding the keyguard.
          */
         boolean onDismiss();
+
+        /**
+         * Whether running this action when we are locked will start an animation on the keyguard.
+         */
+        default boolean willRunAnimationOnKeyguard() {
+            return false;
+        }
     }
 }

packages/SystemUI/src/com/android/systemui/statusbar/phone/StatusBar.java

@@ -2841,9 +2841,11 @@ public class StatusBar extends SystemUI implements DemoMode,
                 mActivityIntentHelper.wouldLaunchResolverActivity(intent,
                         mLockscreenUserManager.getCurrentUserId());
 
+        boolean animate =
+                animationController != null && !willLaunchResolverActivity && shouldAnimateLaunch(
+                        true /* isActivityIntent */);
         ActivityLaunchAnimator.Controller animController =
-                !willLaunchResolverActivity && shouldAnimateLaunch(true /* isActivityIntent */)
+                animate ? wrapAnimationController(animationController, dismissShade) : null;
-                        ? wrapAnimationController(animationController, dismissShade) : null;
 
         // If we animate, we will dismiss the shade only once the animation is done. This is taken
         // care of by the StatusBarLaunchAnimationController.
@@ -2857,7 +2859,7 @@ public class StatusBar extends SystemUI implements DemoMode,
             int[] result = new int[]{ActivityManager.START_CANCELED};
 
             mActivityLaunchAnimator.startIntentWithAnimation(animController,
-                    true /* animate */, intent.getPackage(), (adapter) -> {
+                    animate, intent.getPackage(), (adapter) -> {
                         ActivityOptions options = new ActivityOptions(
                                 getActivityOptions(mDisplayId, adapter));
                         options.setDisallowEnterPictureInPictureWhileLaunching(
@@ -2907,16 +2909,12 @@ public class StatusBar extends SystemUI implements DemoMode,
             }
         };
         executeRunnableDismissingKeyguard(runnable, cancelRunnable, dismissShadeDirectly,
-                willLaunchResolverActivity, true /* deferred */);
+                willLaunchResolverActivity, true /* deferred */, animate);
     }
 
     @Nullable
     private ActivityLaunchAnimator.Controller wrapAnimationController(
-            @Nullable ActivityLaunchAnimator.Controller animationController, boolean dismissShade) {
+            ActivityLaunchAnimator.Controller animationController, boolean dismissShade) {
-        if (animationController == null) {
-            return null;
-        }
-
         View rootView = animationController.getLaunchContainer().getRootView();
         if (rootView == mSuperStatusBarViewFactory.getStatusBarWindowView()) {
             // We are animating a view in the status bar. We have to make sure that the status bar
@@ -2959,34 +2957,56 @@ public class StatusBar extends SystemUI implements DemoMode,
             final boolean dismissShade,
             final boolean afterKeyguardGone,
             final boolean deferred) {
-        dismissKeyguardThenExecute(() -> {
+        executeRunnableDismissingKeyguard(runnable, cancelAction, dismissShade, afterKeyguardGone,
-            if (runnable != null) {
+                deferred, false /* willAnimateOnKeyguard */);
-                if (mStatusBarKeyguardViewManager.isShowing()
+    }
-                        && mStatusBarKeyguardViewManager.isOccluded()) {
-                    mStatusBarKeyguardViewManager.addAfterKeyguardGoneRunnable(runnable);
-                } else {
-                    AsyncTask.execute(runnable);
-                }
-            }
-            if (dismissShade) {
-                if (mExpandedVisible && !mBouncerShowing) {
-                    mShadeController.animateCollapsePanels(CommandQueue.FLAG_EXCLUDE_RECENTS_PANEL,
-                            true /* force */, true /* delayed*/);
-                } else {
 
-                    // Do it after DismissAction has been processed to conserve the needed ordering.
+    public void executeRunnableDismissingKeyguard(final Runnable runnable,
-                    mHandler.post(mShadeController::runPostCollapseRunnables);
+            final Runnable cancelAction,
+            final boolean dismissShade,
+            final boolean afterKeyguardGone,
+            final boolean deferred,
+            final boolean willAnimateOnKeyguard) {
+        OnDismissAction onDismissAction = new OnDismissAction() {
+            @Override
+            public boolean onDismiss() {
+                if (runnable != null) {
+                    if (mStatusBarKeyguardViewManager.isShowing()
+                            && mStatusBarKeyguardViewManager.isOccluded()) {
+                        mStatusBarKeyguardViewManager.addAfterKeyguardGoneRunnable(runnable);
+                    } else {
+                        AsyncTask.execute(runnable);
+                    }
                 }
-            } else if (isInLaunchTransition()
+                if (dismissShade) {
-                    && mNotificationPanelViewController.isLaunchTransitionFinished()) {
+                    if (mExpandedVisible && !mBouncerShowing) {
+                        mShadeController.animateCollapsePanels(
+                                CommandQueue.FLAG_EXCLUDE_RECENTS_PANEL,
+                                true /* force */, true /* delayed*/);
+                    } else {
 
-                // We are not dismissing the shade, but the launch transition is already finished,
+                        // Do it after DismissAction has been processed to conserve the needed
-                // so nobody will call readyForKeyguardDone anymore. Post it such that
+                        // ordering.
-                // keyguardDonePending gets called first.
+                        mHandler.post(mShadeController::runPostCollapseRunnables);
-                mHandler.post(mStatusBarKeyguardViewManager::readyForKeyguardDone);
+                    }
+                } else if (StatusBar.this.isInLaunchTransition()
+                        && mNotificationPanelViewController.isLaunchTransitionFinished()) {
+
+                    // We are not dismissing the shade, but the launch transition is already
+                    // finished,
+                    // so nobody will call readyForKeyguardDone anymore. Post it such that
+                    // keyguardDonePending gets called first.
+                    mHandler.post(mStatusBarKeyguardViewManager::readyForKeyguardDone);
+                }
+                return deferred;
             }
-            return deferred;
+
-        }, cancelAction, afterKeyguardGone);
+            @Override
+            public boolean willRunAnimationOnKeyguard() {
+                return willAnimateOnKeyguard;
+            }
+        };
+        dismissKeyguardThenExecute(onDismissAction, cancelAction, afterKeyguardGone);
     }
 
     private final BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {
@@ -4609,28 +4629,37 @@ public class StatusBar extends SystemUI implements DemoMode,
      *
      * @param action The action to execute after dismissing the keyguard.
      * @param collapsePanel Whether we should collapse the panel after dismissing the keyguard.
-     * @param deferKeyguardDismiss Whether we should defer the keyguard actual dismissal, for
+     * @param willAnimateOnKeyguard Whether {@param action} will run an animation on the keyguard if
-     *                             instance to run animations on the keyguard before hiding it.
+     *                              we are locked.
      */
     private void executeActionDismissingKeyguard(Runnable action, boolean afterKeyguardGone,
-            boolean collapsePanel, boolean deferKeyguardDismiss) {
+            boolean collapsePanel, boolean willAnimateOnKeyguard) {
         if (!mDeviceProvisionedController.isDeviceProvisioned()) return;
 
-        dismissKeyguardThenExecute(() -> {
+        OnDismissAction onDismissAction = new OnDismissAction() {
-            new Thread(() -> {
+            @Override
-                try {
+            public boolean onDismiss() {
-                    // The intent we are sending is for the application, which
+                new Thread(() -> {
-                    // won't have permission to immediately start an activity after
+                    try {
-                    // the user switches to home.  We know it is safe to do at this
+                        // The intent we are sending is for the application, which
-                    // point, so make sure new activity switches are now allowed.
+                        // won't have permission to immediately start an activity after
-                    ActivityManager.getService().resumeAppSwitches();
+                        // the user switches to home.  We know it is safe to do at this
-                } catch (RemoteException e) {
+                        // point, so make sure new activity switches are now allowed.
-                }
+                        ActivityManager.getService().resumeAppSwitches();
-                action.run();
+                    } catch (RemoteException e) {
-            }).start();
+                    }
+                    action.run();
+                }).start();
 
-            return collapsePanel ? mShadeController.collapsePanel() : deferKeyguardDismiss;
+                return collapsePanel ? mShadeController.collapsePanel() : willAnimateOnKeyguard;
-        }, afterKeyguardGone);
+            }
+
+            @Override
+            public boolean willRunAnimationOnKeyguard() {
+                return willAnimateOnKeyguard;
+            }
+        };
+        dismissKeyguardThenExecute(onDismissAction, afterKeyguardGone);
     }
 
     @Override
@@ -4674,7 +4703,6 @@ public class StatusBar extends SystemUI implements DemoMode,
         // the animation on the keyguard). The animation will take care of (instantly) collapsing
         // the shade and hiding the keyguard once it is done.
         boolean collapse = !animate;
-        boolean deferKeyguardDismiss = animate;
         executeActionDismissingKeyguard(() -> {
             try {
                 // We wrap animationCallback with a StatusBarLaunchAnimatorController so that the
@@ -4703,7 +4731,7 @@ public class StatusBar extends SystemUI implements DemoMode,
             if (intentSentUiThreadCallback != null) {
                 postOnUiThread(intentSentUiThreadCallback);
             }
-        }, willLaunchResolverActivity, collapse, deferKeyguardDismiss);
+        }, willLaunchResolverActivity, collapse, animate);
     }
 
     private void postOnUiThread(Runnable runnable) {

packages/SystemUI/src/com/android/systemui/statusbar/phone/StatusBarKeyguardViewManager.java

@@ -192,6 +192,7 @@ public class StatusBarKeyguardViewManager implements RemoteInputController.Callb
 
     private OnDismissAction mAfterKeyguardGoneAction;
     private Runnable mKeyguardGoneCancelAction;
+    private boolean mDismissActionWillAnimateOnKeyguard;
     private final ArrayList<Runnable> mAfterKeyguardGoneRunnables = new ArrayList<>();
 
     // Dismiss action to be launched when we stop dozing or the keyguard is gone.
@@ -447,6 +448,7 @@ public class StatusBarKeyguardViewManager implements RemoteInputController.Callb
 
             mAfterKeyguardGoneAction = r;
             mKeyguardGoneCancelAction = cancelAction;
+            mDismissActionWillAnimateOnKeyguard = r != null && r.willRunAnimationOnKeyguard();
 
             // If there is an an alternate auth interceptor (like the UDFPS), show that one instead
             // of the bouncer.
@@ -625,9 +627,12 @@ public class StatusBarKeyguardViewManager implements RemoteInputController.Callb
             mBouncer.startPreHideAnimation(finishRunnable);
             mStatusBar.onBouncerPreHideAnimation();
 
-            // startPreHideAnimation() will change the visibility of the bouncer, so we have to
+            // We update the state (which will show the keyguard) only if an animation will run on
-            // make sure to update its state.
+            // the keyguard. If there is no animation, we wait before updating the state so that we
-            updateStates();
+            // go directly from bouncer to launcher/app.
+            if (mDismissActionWillAnimateOnKeyguard) {
+                updateStates();
+            }
         } else if (finishRunnable != null) {
             finishRunnable.run();
         }
@@ -798,6 +803,7 @@ public class StatusBarKeyguardViewManager implements RemoteInputController.Callb
             mAfterKeyguardGoneAction = null;
         }
         mKeyguardGoneCancelAction = null;
+        mDismissActionWillAnimateOnKeyguard = false;
         for (int i = 0; i < mAfterKeyguardGoneRunnables.size(); i++) {
             mAfterKeyguardGoneRunnables.get(i).run();
         }
@@ -866,6 +872,7 @@ public class StatusBarKeyguardViewManager implements RemoteInputController.Callb
             return; // allow bouncer to trigger saved actions
         }
         mAfterKeyguardGoneAction = null;
+        mDismissActionWillAnimateOnKeyguard = false;
         if (mKeyguardGoneCancelAction != null) {
             mKeyguardGoneCancelAction.run();
             mKeyguardGoneCancelAction = null;

packages/SystemUI/src/com/android/systemui/statusbar/phone/StatusBarNotificationActivityStarter.java

@@ -260,10 +260,19 @@ public class StatusBarNotificationActivityStarter implements NotificationActivit
         boolean showOverLockscreen = mKeyguardStateController.isShowing() && intent != null
                 && mActivityIntentHelper.wouldShowOverLockscreen(intent.getIntent(),
                 mLockscreenUserManager.getCurrentUserId());
-        ActivityStarter.OnDismissAction postKeyguardAction =
+        ActivityStarter.OnDismissAction postKeyguardAction = new ActivityStarter.OnDismissAction() {
-                () -> handleNotificationClickAfterKeyguardDismissed(
+            @Override
+            public boolean onDismiss() {
+                return handleNotificationClickAfterKeyguardDismissed(
                         entry, row, controller, intent,
                         isActivityIntent, animate, showOverLockscreen);
+            }
+
+            @Override
+            public boolean willRunAnimationOnKeyguard() {
+                return animate;
+            }
+        };
         if (showOverLockscreen) {
             mIsCollapsingToShowActivityOverLockscreen = true;
             postKeyguardAction.onDismiss();
@@ -453,53 +462,73 @@ public class StatusBarNotificationActivityStarter implements NotificationActivit
     public void startNotificationGutsIntent(final Intent intent, final int appUid,
             ExpandableNotificationRow row) {
         boolean animate = mStatusBar.shouldAnimateLaunch(true /* isActivityIntent */);
-        mActivityStarter.dismissKeyguardThenExecute(() -> {
+        ActivityStarter.OnDismissAction onDismissAction = new ActivityStarter.OnDismissAction() {
-            AsyncTask.execute(() -> {
+            @Override
-                ActivityLaunchAnimator.Controller animationController =
+            public boolean onDismiss() {
-                        new StatusBarLaunchAnimatorController(
+                AsyncTask.execute(() -> {
-                                mNotificationAnimationProvider.getAnimatorController(row),
+                    ActivityLaunchAnimator.Controller animationController =
-                                mStatusBar, true /* isActivityIntent */);
+                            new StatusBarLaunchAnimatorController(
+                                    mNotificationAnimationProvider.getAnimatorController(row),
+                                    mStatusBar, true /* isActivityIntent */);
 
-                mActivityLaunchAnimator.startIntentWithAnimation(
+                    mActivityLaunchAnimator.startIntentWithAnimation(
-                        animationController, animate, intent.getPackage(),
+                            animationController, animate, intent.getPackage(),
-                        (adapter) -> TaskStackBuilder.create(mContext)
+                            (adapter) -> TaskStackBuilder.create(mContext)
-                                .addNextIntentWithParentStack(intent)
+                                    .addNextIntentWithParentStack(intent)
-                                .startActivities(getActivityOptions(
+                                    .startActivities(getActivityOptions(
-                                        mStatusBar.getDisplayId(),
+                                            mStatusBar.getDisplayId(),
-                                        adapter),
+                                            adapter),
-                                        new UserHandle(UserHandle.getUserId(appUid))));
+                                            new UserHandle(UserHandle.getUserId(appUid))));
-            });
+                });
-            return true;
+                return true;
-        }, null, false /* afterKeyguardGone */);
+            }
+
+            @Override
+            public boolean willRunAnimationOnKeyguard() {
+                return animate;
+            }
+        };
+        mActivityStarter.dismissKeyguardThenExecute(onDismissAction, null,
+                false /* afterKeyguardGone */);
     }
 
     @Override
     public void startHistoryIntent(View view, boolean showHistory) {
         boolean animate = mStatusBar.shouldAnimateLaunch(true /* isActivityIntent */);
-        mActivityStarter.dismissKeyguardThenExecute(() -> {
+        ActivityStarter.OnDismissAction onDismissAction = new ActivityStarter.OnDismissAction() {
-            AsyncTask.execute(() -> {
+            @Override
-                Intent intent = showHistory ? new Intent(
+            public boolean onDismiss() {
-                        Settings.ACTION_NOTIFICATION_HISTORY) : new Intent(
+                AsyncTask.execute(() -> {
-                        Settings.ACTION_NOTIFICATION_SETTINGS);
+                    Intent intent = showHistory ? new Intent(
-                TaskStackBuilder tsb = TaskStackBuilder.create(mContext)
+                            Settings.ACTION_NOTIFICATION_HISTORY) : new Intent(
-                        .addNextIntent(new Intent(Settings.ACTION_NOTIFICATION_SETTINGS));
+                            Settings.ACTION_NOTIFICATION_SETTINGS);
-                if (showHistory) {
+                    TaskStackBuilder tsb = TaskStackBuilder.create(mContext)
-                    tsb.addNextIntent(intent);
+                            .addNextIntent(new Intent(Settings.ACTION_NOTIFICATION_SETTINGS));
-                }
+                    if (showHistory) {
+                        tsb.addNextIntent(intent);
+                    }
 
-                ActivityLaunchAnimator.Controller animationController =
+                    ActivityLaunchAnimator.Controller animationController =
-                        new StatusBarLaunchAnimatorController(
+                            new StatusBarLaunchAnimatorController(
-                                ActivityLaunchAnimator.Controller.fromView(view), mStatusBar,
+                                    ActivityLaunchAnimator.Controller.fromView(view), mStatusBar,
-                                true /* isActivityIntent */);
+                                    true /* isActivityIntent */);
 
-                mActivityLaunchAnimator.startIntentWithAnimation(animationController, animate,
+                    mActivityLaunchAnimator.startIntentWithAnimation(animationController, animate,
-                        intent.getPackage(),
+                            intent.getPackage(),
-                        (adapter) -> tsb.startActivities(
+                            (adapter) -> tsb.startActivities(
-                                getActivityOptions(mStatusBar.getDisplayId(), adapter),
+                                    getActivityOptions(mStatusBar.getDisplayId(), adapter),
-                                UserHandle.CURRENT));
+                                    UserHandle.CURRENT));
-            });
+                });
-            return true;
+                return true;
-        }, null, false /* afterKeyguardGone */);
+            }
+
+            @Override
+            public boolean willRunAnimationOnKeyguard() {
+                return animate;
+            }
+        };
+        mActivityStarter.dismissKeyguardThenExecute(onDismissAction, null,
+                false /* afterKeyguardGone */);
     }
 
     private void removeHunAfterClick(ExpandableNotificationRow row) {