From 821e37b44768198b4bddb302a0c87de3ff31f1ae Mon Sep 17 00:00:00 2001 From: Tony Wickham Date: Tue, 16 Nov 2021 17:38:36 -0800 Subject: [PATCH] Stash taskbar when IME is present, including during gestures - SysUI removes SYSUI_STATE_IME_SHOWING when starting a gesture from an app, but because unstashing has implications on the gesture transition (e.g. clips the bottom of the app), we defer handling the ime hiding until the gesture settles. Repurposed the flow that swaps the taskbar background during the gesture to support this case as well. - Delay the unstash when IME is closing, to align with the end of the IME exit transition - Remove TaskbarViewController.ALPHA_INDEX_IME now that we stash when IME is opening, since stashing already hides the taskbar icons - Also support passing a starting progress to the stashed handle reveal animation, to allow it to be reversed when cancelled. For example, when returning to an app that has IME showing, we first start unstashing because we're in an app, but then we get the signal that IME is attached so we stash again almost immediately (within a frame or two). Test: In both 3 button and fully gestural, open a keyboard in an app, ensure taskbar gets out of the way and then reappears at the end when the keyboard is dismissed Bug: 202511986 Change-Id: I93c298a98ba369ea6310466ff3f802231c582687 --- .../taskbar/FallbackTaskbarUIController.java | 5 +- .../taskbar/LauncherTaskbarUIController.java | 16 +-- .../taskbar/NavbarButtonsViewController.java | 8 +- .../taskbar/StashedHandleViewController.java | 33 +++++-- .../taskbar/TaskbarDragLayerController.java | 8 +- .../taskbar/TaskbarStashController.java | 99 ++++++++++++++++--- .../taskbar/TaskbarUIController.java | 20 +++- .../taskbar/TaskbarViewController.java | 11 +-- .../android/quickstep/AbsSwipeUpHandler.java | 19 ++-- .../quickstep/BaseActivityInterface.java | 16 +++ .../quickstep/LauncherActivityInterface.java | 27 ----- .../anim/RevealOutlineAnimation.java | 22 ++++- 12 files changed, 200 insertions(+), 84 deletions(-) diff --git a/quickstep/src/com/android/launcher3/taskbar/FallbackTaskbarUIController.java b/quickstep/src/com/android/launcher3/taskbar/FallbackTaskbarUIController.java index 24a88a4043..90c035fed0 100644 --- a/quickstep/src/com/android/launcher3/taskbar/FallbackTaskbarUIController.java +++ b/quickstep/src/com/android/launcher3/taskbar/FallbackTaskbarUIController.java @@ -46,16 +46,13 @@ public class FallbackTaskbarUIController extends TaskbarUIController { } }; - // Initialized in init. - TaskbarControllers mControllers; - public FallbackTaskbarUIController(RecentsActivity recentsActivity) { mRecentsActivity = recentsActivity; } @Override protected void init(TaskbarControllers taskbarControllers) { - mControllers = taskbarControllers; + super.init(taskbarControllers); mRecentsActivity.setTaskbarUIController(this); mRecentsActivity.getStateManager().addStateListener(mStateListener); diff --git a/quickstep/src/com/android/launcher3/taskbar/LauncherTaskbarUIController.java b/quickstep/src/com/android/launcher3/taskbar/LauncherTaskbarUIController.java index 1c0c77328f..7d234392c4 100644 --- a/quickstep/src/com/android/launcher3/taskbar/LauncherTaskbarUIController.java +++ b/quickstep/src/com/android/launcher3/taskbar/LauncherTaskbarUIController.java @@ -25,7 +25,6 @@ import android.os.RemoteException; import android.util.Log; import android.view.MotionEvent; import android.view.TaskTransitionSpec; -import android.view.View; import android.view.WindowManagerGlobal; import androidx.annotation.NonNull; @@ -62,7 +61,6 @@ public class LauncherTaskbarUIController extends TaskbarUIController { this::onStashedInAppChanged; // Initialized in init. - private TaskbarControllers mControllers; private AnimatedFloat mTaskbarOverrideBackgroundAlpha; private TaskbarKeyguardController mKeyguardController; private final TaskbarLauncherStateController @@ -83,7 +81,7 @@ public class LauncherTaskbarUIController extends TaskbarUIController { @Override protected void init(TaskbarControllers taskbarControllers) { - mControllers = taskbarControllers; + super.init(taskbarControllers); mTaskbarLauncherStateController.init(mControllers, mLauncher); mTaskbarOverrideBackgroundAlpha = mControllers.taskbarDragLayerController @@ -168,10 +166,6 @@ public class LauncherTaskbarUIController extends TaskbarUIController { return mControllers.taskbarDragController.isDragging(); } - public View getRootView() { - return mControllers.taskbarActivityContext.getDragLayer(); - } - @Override protected void onStashedInAppChanged() { onStashedInAppChanged(mLauncher.getDeviceProfile()); @@ -251,4 +245,12 @@ public class LauncherTaskbarUIController extends TaskbarUIController { mLauncher.logAppLaunch(mControllers.taskbarActivityContext.getStatsLogManager(), item, instanceId); } + + @Override + public void setSystemGestureInProgress(boolean inProgress) { + super.setSystemGestureInProgress(inProgress); + // Launcher's ScrimView will draw the background throughout the gesture. But once the + // gesture ends, start drawing taskbar's background again since launcher might stop drawing. + forceHideBackground(inProgress); + } } diff --git a/quickstep/src/com/android/launcher3/taskbar/NavbarButtonsViewController.java b/quickstep/src/com/android/launcher3/taskbar/NavbarButtonsViewController.java index 0565f7e976..f6e0426fd4 100644 --- a/quickstep/src/com/android/launcher3/taskbar/NavbarButtonsViewController.java +++ b/quickstep/src/com/android/launcher3/taskbar/NavbarButtonsViewController.java @@ -21,7 +21,6 @@ import static com.android.launcher3.taskbar.TaskbarNavButtonController.BUTTON_BA import static com.android.launcher3.taskbar.TaskbarNavButtonController.BUTTON_HOME; import static com.android.launcher3.taskbar.TaskbarNavButtonController.BUTTON_IME_SWITCH; import static com.android.launcher3.taskbar.TaskbarNavButtonController.BUTTON_RECENTS; -import static com.android.launcher3.taskbar.TaskbarViewController.ALPHA_INDEX_IME; import static com.android.launcher3.taskbar.TaskbarViewController.ALPHA_INDEX_KEYGUARD; import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_A11Y_BUTTON_CLICKABLE; import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_A11Y_BUTTON_LONG_CLICKABLE; @@ -140,11 +139,6 @@ public class NavbarButtonsViewController { mNavButtonsView.getLayoutParams().height = mContext.getDeviceProfile().taskbarSize; mNavButtonTranslationYMultiplier.value = 1; - mPropertyHolders.add(new StatePropertyHolder( - mControllers.taskbarViewController.getTaskbarIconAlpha() - .getProperty(ALPHA_INDEX_IME), - flags -> (flags & FLAG_IME_VISIBLE) == 0, MultiValueAlpha.VALUE, 1, 0)); - boolean isThreeButtonNav = mContext.isThreeButtonNav(); // IME switcher View imeSwitcherButton = addButton(R.drawable.ic_ime_switcher, BUTTON_IME_SWITCH, @@ -196,7 +190,7 @@ public class NavbarButtonsViewController { } // Animate taskbar background when any of these flags are enabled - int flagsToShowBg = FLAG_IME_VISIBLE | FLAG_ONLY_BACK_FOR_BOUNCER_VISIBLE + int flagsToShowBg = FLAG_ONLY_BACK_FOR_BOUNCER_VISIBLE | FLAG_NOTIFICATION_SHADE_EXPANDED; mPropertyHolders.add(new StatePropertyHolder( mControllers.taskbarDragLayerController.getNavbarBackgroundAlpha(), diff --git a/quickstep/src/com/android/launcher3/taskbar/StashedHandleViewController.java b/quickstep/src/com/android/launcher3/taskbar/StashedHandleViewController.java index 2c80f06eb1..22ca63f963 100644 --- a/quickstep/src/com/android/launcher3/taskbar/StashedHandleViewController.java +++ b/quickstep/src/com/android/launcher3/taskbar/StashedHandleViewController.java @@ -16,6 +16,8 @@ package com.android.launcher3.taskbar; import android.animation.Animator; +import android.animation.AnimatorListenerAdapter; +import android.animation.ValueAnimator; import android.content.SharedPreferences; import android.content.res.Resources; import android.graphics.Outline; @@ -23,8 +25,6 @@ import android.graphics.Rect; import android.view.View; import android.view.ViewOutlineProvider; -import androidx.annotation.Nullable; - import com.android.launcher3.R; import com.android.launcher3.Utilities; import com.android.launcher3.anim.RevealOutlineAnimation; @@ -66,7 +66,10 @@ public class StashedHandleViewController { private final Rect mStashedHandleBounds = new Rect(); private float mStashedHandleRadius; - private boolean mIsAtStashedRevealBounds = true; + // When the reveal animation is cancelled, we can assume it's about to create a new animation, + // which should start off at the same point the cancelled one left off. + private float mStartProgressForNextRevealAnim; + private boolean mWasLastRevealAnimReversed; public StashedHandleViewController(TaskbarActivityContext activity, StashedHandleView stashedHandleView) { @@ -148,15 +151,27 @@ public class StashedHandleViewController { * shape and size. When stashed, the shape is a thin rounded pill. When unstashed, the shape * morphs into the size of where the taskbar icons will be. */ - public @Nullable Animator createRevealAnimToIsStashed(boolean isStashed) { - if (mIsAtStashedRevealBounds == isStashed) { - return null; - } - mIsAtStashedRevealBounds = isStashed; + public Animator createRevealAnimToIsStashed(boolean isStashed) { final RevealOutlineAnimation handleRevealProvider = new RoundedRectRevealOutlineProvider( mStashedHandleRadius, mStashedHandleRadius, mControllers.taskbarViewController.getIconLayoutBounds(), mStashedHandleBounds); - return handleRevealProvider.createRevealAnimator(mStashedHandleView, !isStashed); + + boolean isReversed = !isStashed; + boolean changingDirection = mWasLastRevealAnimReversed != isReversed; + mWasLastRevealAnimReversed = isReversed; + if (changingDirection) { + mStartProgressForNextRevealAnim = 1f - mStartProgressForNextRevealAnim; + } + + ValueAnimator revealAnim = handleRevealProvider.createRevealAnimator(mStashedHandleView, + isReversed, mStartProgressForNextRevealAnim); + revealAnim.addListener(new AnimatorListenerAdapter() { + @Override + public void onAnimationEnd(Animator animation) { + mStartProgressForNextRevealAnim = ((ValueAnimator) animation).getAnimatedFraction(); + } + }); + return revealAnim; } public void onIsStashed(boolean isStashed) { diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarDragLayerController.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarDragLayerController.java index 248c40d978..806b39093f 100644 --- a/quickstep/src/com/android/launcher3/taskbar/TaskbarDragLayerController.java +++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarDragLayerController.java @@ -44,6 +44,7 @@ public class TaskbarDragLayerController { private final AnimatedFloat mKeyguardBgTaskbar = new AnimatedFloat(this::updateBackgroundAlpha); private final AnimatedFloat mNotificationShadeBgTaskbar = new AnimatedFloat( this::updateBackgroundAlpha); + private final AnimatedFloat mImeBgTaskbar = new AnimatedFloat(this::updateBackgroundAlpha); // Used to hide our background color when someone else (e.g. ScrimView) is handling it. private final AnimatedFloat mBgOverride = new AnimatedFloat(this::updateBackgroundAlpha); @@ -74,6 +75,7 @@ public class TaskbarDragLayerController { mBgTaskbar.value = 1; mKeyguardBgTaskbar.value = 1; mNotificationShadeBgTaskbar.value = 1; + mImeBgTaskbar.value = 1; mBgOverride.value = 1; updateBackgroundAlpha(); } @@ -108,6 +110,10 @@ public class TaskbarDragLayerController { return mNotificationShadeBgTaskbar; } + public AnimatedFloat getImeBgTaskbar() { + return mImeBgTaskbar; + } + public AnimatedFloat getOverrideBackgroundAlpha() { return mBgOverride; } @@ -119,7 +125,7 @@ public class TaskbarDragLayerController { private void updateBackgroundAlpha() { final float bgNavbar = mBgNavbar.value; final float bgTaskbar = mBgTaskbar.value * mKeyguardBgTaskbar.value - * mNotificationShadeBgTaskbar.value; + * mNotificationShadeBgTaskbar.value * mImeBgTaskbar.value; mLastSetBackgroundAlpha = mBgOverride.value * Math.max(bgNavbar, bgTaskbar); mTaskbarDragLayer.setTaskbarBackgroundAlpha(mLastSetBackgroundAlpha); diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarStashController.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarStashController.java index 60842c8d72..8965dc4816 100644 --- a/quickstep/src/com/android/launcher3/taskbar/TaskbarStashController.java +++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarStashController.java @@ -19,6 +19,7 @@ import static android.view.HapticFeedbackConstants.LONG_PRESS; import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_TASKBAR_LONGPRESS_HIDE; import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_TASKBAR_LONGPRESS_SHOW; +import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_IME_SHOWING; import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_SCREEN_PINNING; import android.animation.Animator; @@ -48,17 +49,24 @@ public class TaskbarStashController { public static final int FLAG_STASHED_IN_APP_PINNED = 1 << 2; // app pinning public static final int FLAG_STASHED_IN_APP_EMPTY = 1 << 3; // no hotseat icons public static final int FLAG_STASHED_IN_APP_SETUP = 1 << 4; // setup wizard and AllSetActivity - public static final int FLAG_IN_STASHED_LAUNCHER_STATE = 1 << 5; + public static final int FLAG_STASHED_IN_APP_IME = 1 << 5; // IME is visible + public static final int FLAG_IN_STASHED_LAUNCHER_STATE = 1 << 6; // If we're in an app and any of these flags are enabled, taskbar should be stashed. public static final int FLAGS_STASHED_IN_APP = FLAG_STASHED_IN_APP_MANUAL - | FLAG_STASHED_IN_APP_PINNED | FLAG_STASHED_IN_APP_EMPTY | FLAG_STASHED_IN_APP_SETUP; + | FLAG_STASHED_IN_APP_PINNED | FLAG_STASHED_IN_APP_EMPTY | FLAG_STASHED_IN_APP_SETUP + | FLAG_STASHED_IN_APP_IME; /** * How long to stash/unstash when manually invoked via long press. */ public static final long TASKBAR_STASH_DURATION = 300; + /** + * How long to stash/unstash when keyboard is appearing/disappearing. + */ + private static final long TASKBAR_STASH_DURATION_FOR_IME = 80; + /** * The scale TaskbarView animates to when being stashed. */ @@ -100,6 +108,7 @@ public class TaskbarStashController { private TaskbarControllers mControllers; // Taskbar background properties. private AnimatedFloat mTaskbarBackgroundOffset; + private AnimatedFloat mTaskbarImeBgAlpha; // TaskbarView icon properties. private AlphaProperty mIconAlphaForStash; private AnimatedFloat mIconScaleForStash; @@ -113,6 +122,8 @@ public class TaskbarStashController { private int mState; private @Nullable AnimatorSet mAnimator; + private boolean mIsSystemGestureInProgress; + private boolean mIsImeShowing; // Evaluate whether the handle should be stashed private final StatePropertyHolder mStatePropertyHolder = new StatePropertyHolder( @@ -137,6 +148,7 @@ public class TaskbarStashController { TaskbarDragLayerController dragLayerController = controllers.taskbarDragLayerController; mTaskbarBackgroundOffset = dragLayerController.getTaskbarBackgroundOffset(); + mTaskbarImeBgAlpha = dragLayerController.getImeBgTaskbar(); TaskbarViewController taskbarViewController = controllers.taskbarViewController; mIconAlphaForStash = taskbarViewController.getTaskbarIconAlpha().getProperty( @@ -271,17 +283,21 @@ public class TaskbarStashController { * Create a stash animation and save to {@link #mAnimator}. * @param isStashed whether it's a stash animation or an unstash animation * @param duration duration of the animation + * @param startDelay how many milliseconds to delay the animation after starting it. */ - private void createAnimToIsStashed(boolean isStashed, long duration) { + private void createAnimToIsStashed(boolean isStashed, long duration, long startDelay) { if (mAnimator != null) { mAnimator.cancel(); } mAnimator = new AnimatorSet(); if (!supportsVisualStashing()) { - // Just hide/show the icons instead of stashing into a handle. + // Just hide/show the icons and background instead of stashing into a handle. mAnimator.play(mIconAlphaForStash.animateToValue(isStashed ? 0 : 1) .setDuration(duration)); + mAnimator.play(mTaskbarImeBgAlpha.animateToValue( + hasAnyFlag(FLAG_STASHED_IN_APP_IME) ? 0 : 1).setDuration(duration)); + mAnimator.setStartDelay(startDelay); mAnimator.addListener(new AnimatorListenerAdapter() { @Override public void onAnimationEnd(Animator animation) { @@ -332,11 +348,8 @@ public class TaskbarStashController { ); } - Animator stashedHandleRevealAnim = mControllers.stashedHandleViewController - .createRevealAnimToIsStashed(isStashed); - if (stashedHandleRevealAnim != null) { - fullLengthAnimatorSet.play(stashedHandleRevealAnim); - } + fullLengthAnimatorSet.play(mControllers.stashedHandleViewController + .createRevealAnimToIsStashed(isStashed)); // Return the stashed handle to its default scale in case it was changed as part of the // feedforward hint. Note that the reveal animation above also visually scales it. fullLengthAnimatorSet.play(mTaskbarStashedHandleHintScale.animateToValue(1f)); @@ -348,6 +361,7 @@ public class TaskbarStashController { mAnimator.playTogether(fullLengthAnimatorSet, firstHalfAnimatorSet, secondHalfAnimatorSet); + mAnimator.setStartDelay(startDelay); mAnimator.addListener(new AnimatorListenerAdapter() { @Override public void onAnimationStart(Animator animation) { @@ -406,6 +420,10 @@ public class TaskbarStashController { mStatePropertyHolder.setState(mState, duration, true); } + public void applyState(long duration, long startDelay) { + mStatePropertyHolder.setState(mState, duration, startDelay, true); + } + public Animator applyStateWithoutStart() { return applyStateWithoutStart(TASKBAR_STASH_DURATION); } @@ -414,11 +432,50 @@ public class TaskbarStashController { return mStatePropertyHolder.setState(mState, duration, false); } + /** + * Should be called when a system gesture starts and settles, so we can defer updating + * FLAG_STASHED_IN_APP_IME until after the gesture transition completes. + */ + public void setSystemGestureInProgress(boolean inProgress) { + mIsSystemGestureInProgress = inProgress; + // Only update FLAG_STASHED_IN_APP_IME when system gesture is not in progress. + if (!mIsSystemGestureInProgress) { + updateStateForFlag(FLAG_STASHED_IN_APP_IME, mIsImeShowing); + applyState(TASKBAR_STASH_DURATION_FOR_IME, getTaskbarStashStartDelayForIme()); + } + } + + /** + * When hiding the IME, delay the unstash animation to align with the end of the transition. + */ + private long getTaskbarStashStartDelayForIme() { + if (mIsImeShowing) { + // Only delay when IME is exiting, not entering. + return 0; + } + // This duration is based on input_method_extract_exit.xml. + long imeExitDuration = mControllers.taskbarActivityContext.getResources() + .getInteger(android.R.integer.config_shortAnimTime); + return imeExitDuration - TASKBAR_STASH_DURATION_FOR_IME; + } + /** Called when some system ui state has changed. (See SYSUI_STATE_... in QuickstepContract) */ public void updateStateForSysuiFlags(int systemUiStateFlags, boolean skipAnim) { + long animDuration = TASKBAR_STASH_DURATION; + long startDelay = 0; + updateStateForFlag(FLAG_STASHED_IN_APP_PINNED, hasAnyFlag(systemUiStateFlags, SYSUI_STATE_SCREEN_PINNING)); - applyState(skipAnim ? 0 : TASKBAR_STASH_DURATION); + + // Only update FLAG_STASHED_IN_APP_IME when system gesture is not in progress. + mIsImeShowing = hasAnyFlag(systemUiStateFlags, SYSUI_STATE_IME_SHOWING); + if (!mIsSystemGestureInProgress) { + updateStateForFlag(FLAG_STASHED_IN_APP_IME, mIsImeShowing); + animDuration = TASKBAR_STASH_DURATION_FOR_IME; + startDelay = getTaskbarStashStartDelayForIme(); + } + + applyState(skipAnim ? 0 : animDuration, skipAnim ? 0 : startDelay); } /** @@ -474,16 +531,34 @@ public class TaskbarStashController { mStashCondition = stashCondition; } + /** + * @see #setState(int, long, long, boolean) with a default startDelay = 0. + */ public Animator setState(int flags, long duration, boolean start) { + return setState(flags, duration, 0 /* startDelay */, start); + } + + /** + * Applies the latest state, potentially calling onStateChangeApplied() and creating a new + * animation (stored in mAnimator) which is started if {@param start} is true. + * @param flags The latest flags to apply (see the top of this file). + * @param duration The length of the animation. + * @param startDelay How long to delay the animation after calling start(). + * @param start Whether to start mAnimator immediately. + * @return mAnimator if mIsStashed changed, else null. + */ + public Animator setState(int flags, long duration, long startDelay, boolean start) { + int changedFlags = mPrevFlags ^ flags; if (mPrevFlags != flags) { - int changedFlags = mPrevFlags ^ flags; onStateChangeApplied(changedFlags); mPrevFlags = flags; } boolean isStashed = mStashCondition.test(flags); if (mIsStashed != isStashed) { mIsStashed = isStashed; - createAnimToIsStashed(mIsStashed, duration); + + // This sets mAnimator. + createAnimToIsStashed(mIsStashed, duration, startDelay); if (start) { mAnimator.start(); } diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarUIController.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarUIController.java index d8360e0fa0..f713dcabcb 100644 --- a/quickstep/src/com/android/launcher3/taskbar/TaskbarUIController.java +++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarUIController.java @@ -16,6 +16,7 @@ package com.android.launcher3.taskbar; import android.graphics.Rect; +import android.view.View; import com.android.launcher3.model.data.ItemInfoWithIcon; import com.android.launcher3.model.data.WorkspaceItemInfo; @@ -29,7 +30,12 @@ public class TaskbarUIController { public static final TaskbarUIController DEFAULT = new TaskbarUIController(); - protected void init(TaskbarControllers taskbarControllers) { } + // Initialized in init. + protected TaskbarControllers mControllers; + + protected void init(TaskbarControllers taskbarControllers) { + mControllers = taskbarControllers; + } protected void onDestroy() { } @@ -46,4 +52,16 @@ public class TaskbarUIController { } public void onTaskbarIconLaunched(WorkspaceItemInfo item) { } + + public View getRootView() { + return mControllers.taskbarActivityContext.getDragLayer(); + } + + /** + * Called when swiping from the bottom nav region in fully gestural mode. + * @param inProgress True if the animation started, false if we just settled on an end target. + */ + public void setSystemGestureInProgress(boolean inProgress) { + mControllers.taskbarStashController.setSystemGestureInProgress(inProgress); + } } diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarViewController.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarViewController.java index c47bde9dcd..445a23bf3f 100644 --- a/quickstep/src/com/android/launcher3/taskbar/TaskbarViewController.java +++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarViewController.java @@ -45,12 +45,11 @@ public class TaskbarViewController { private static final Runnable NO_OP = () -> { }; public static final int ALPHA_INDEX_HOME = 0; - public static final int ALPHA_INDEX_IME = 1; - public static final int ALPHA_INDEX_KEYGUARD = 2; - public static final int ALPHA_INDEX_STASH = 3; - public static final int ALPHA_INDEX_RECENTS_DISABLED = 4; - public static final int ALPHA_INDEX_NOTIFICATION_EXPANDED = 5; - private static final int NUM_ALPHA_CHANNELS = 6; + public static final int ALPHA_INDEX_KEYGUARD = 1; + public static final int ALPHA_INDEX_STASH = 2; + public static final int ALPHA_INDEX_RECENTS_DISABLED = 3; + public static final int ALPHA_INDEX_NOTIFICATION_EXPANDED = 4; + private static final int NUM_ALPHA_CHANNELS = 5; private final TaskbarActivityContext mActivity; private final TaskbarView mTaskbarView; diff --git a/quickstep/src/com/android/quickstep/AbsSwipeUpHandler.java b/quickstep/src/com/android/quickstep/AbsSwipeUpHandler.java index 45b2081952..c9cbba1330 100644 --- a/quickstep/src/com/android/quickstep/AbsSwipeUpHandler.java +++ b/quickstep/src/com/android/quickstep/AbsSwipeUpHandler.java @@ -121,8 +121,8 @@ import com.android.systemui.shared.system.TaskStackChangeListener; import com.android.systemui.shared.system.TaskStackChangeListeners; import java.util.ArrayList; -import java.util.HashMap; import java.util.Arrays; +import java.util.HashMap; import java.util.function.Consumer; /** @@ -687,14 +687,17 @@ public abstract class AbsSwipeUpHandler, } private void onAnimatorPlaybackControllerCreated(AnimatorControllerWithResistance anim) { + boolean isFirstCreation = mLauncherTransitionController == null; mLauncherTransitionController = anim; - mStateCallback.runOnceAtState(STATE_GESTURE_STARTED, () -> { - // Wait until the gesture is started (touch slop was passed) to start in sync with - // mWindowTransitionController. This ensures we don't hide the taskbar background when - // long pressing to stash it, for instance. - mLauncherTransitionController.getNormalController().dispatchOnStart(); - updateLauncherTransitionProgress(); - }); + if (isFirstCreation) { + mStateCallback.runOnceAtState(STATE_GESTURE_STARTED, () -> { + // Wait until the gesture is started (touch slop was passed) to start in sync with + // mWindowTransitionController. This ensures we don't hide the taskbar background + // when long pressing to stash it, for instance. + mLauncherTransitionController.getNormalController().dispatchOnStart(); + updateLauncherTransitionProgress(); + }); + } } public Intent getLaunchIntent() { diff --git a/quickstep/src/com/android/quickstep/BaseActivityInterface.java b/quickstep/src/com/android/quickstep/BaseActivityInterface.java index e15aa92cf1..a566765b9f 100644 --- a/quickstep/src/com/android/quickstep/BaseActivityInterface.java +++ b/quickstep/src/com/android/quickstep/BaseActivityInterface.java @@ -30,6 +30,7 @@ import static com.android.quickstep.views.RecentsView.RECENTS_SCALE_PROPERTY; import static com.android.quickstep.views.RecentsView.TASK_SECONDARY_TRANSLATION; import android.animation.Animator; +import android.animation.AnimatorListenerAdapter; import android.animation.ObjectAnimator; import android.annotation.TargetApi; import android.content.Context; @@ -398,6 +399,11 @@ public abstract class BaseActivityInterface