Merge "Allow user gesture to take priority over taskbar translation reset animnatiuon." into tm-qpr-dev
diff --git a/quickstep/src/com/android/launcher3/taskbar/StashedHandleViewController.java b/quickstep/src/com/android/launcher3/taskbar/StashedHandleViewController.java
index 941b4b0..c4255bf 100644
--- a/quickstep/src/com/android/launcher3/taskbar/StashedHandleViewController.java
+++ b/quickstep/src/com/android/launcher3/taskbar/StashedHandleViewController.java
@@ -49,7 +49,8 @@
public static final int ALPHA_INDEX_STASHED = 0;
public static final int ALPHA_INDEX_HOME_DISABLED = 1;
public static final int ALPHA_INDEX_ASSISTANT_INVOKED = 2;
- private static final int NUM_ALPHA_CHANNELS = 3;
+ public static final int ALPHA_INDEX_HIDDEN_WHILE_DREAMING = 3;
+ private static final int NUM_ALPHA_CHANNELS = 4;
/**
* The SharedPreferences key for whether the stashed handle region is dark.
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarDragLayerController.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarDragLayerController.java
index 2628a7f..2fba37e 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarDragLayerController.java
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarDragLayerController.java
@@ -53,6 +53,10 @@
// Translation property for taskbar background.
private final AnimatedFloat mBgOffset = new AnimatedFloat(this::updateBackgroundOffset);
+ // Used to fade in/out the entirety of the taskbar, for a smooth transition before/after sysui
+ // changes the inset visibility.
+ private final AnimatedFloat mTaskbarAlpha = new AnimatedFloat(this::updateTaskbarAlpha);
+
// Initialized in init.
private TaskbarControllers mControllers;
private TaskbarStashViaTouchController mTaskbarStashViaTouchController;
@@ -83,6 +87,9 @@
mAssistantBgTaskbar.value = 1;
mBgOverride.value = 1;
updateBackgroundAlpha();
+
+ mTaskbarAlpha.value = 1;
+ updateTaskbarAlpha();
}
public void onDestroy() {
@@ -127,6 +134,10 @@
return mBgOffset;
}
+ public AnimatedFloat getTaskbarAlpha() {
+ return mTaskbarAlpha;
+ }
+
/**
* Make updates when configuration changes.
*/
@@ -165,6 +176,10 @@
updateOnBackgroundNavButtonColorIntensity();
}
+ private void updateTaskbarAlpha() {
+ mTaskbarDragLayer.setAlpha(mTaskbarAlpha.value);
+ }
+
@Override
public void setCornerRoundness(float cornerRoundness) {
mTaskbarDragLayer.setCornerRoundness(cornerRoundness);
@@ -188,6 +203,7 @@
pw.println(prefix + "TaskbarDragLayerController:");
pw.println(prefix + "\tmBgOffset=" + mBgOffset.value);
+ pw.println(prefix + "\tmTaskbarAlpha=" + mTaskbarAlpha.value);
pw.println(prefix + "\tmFolderMargin=" + mFolderMargin);
pw.println(prefix + "\tmLastSetBackgroundAlpha=" + mLastSetBackgroundAlpha);
pw.println(prefix + "\t\tmBgOverride=" + mBgOverride.value);
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarLauncherStateController.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarLauncherStateController.java
index 7e016a8..58cb558 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarLauncherStateController.java
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarLauncherStateController.java
@@ -23,11 +23,15 @@
import static com.android.launcher3.util.FlagDebugUtils.formatFlagChange;
import static com.android.systemui.animation.Interpolators.EMPHASIZED;
import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_AWAKE;
+import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_DEVICE_DREAMING;
+import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_WAKEFULNESS_MASK;
+import static com.android.systemui.shared.system.QuickStepContract.WAKEFULNESS_AWAKE;
import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.animation.AnimatorSet;
import android.animation.ObjectAnimator;
+import android.os.SystemClock;
import android.util.Log;
import androidx.annotation.NonNull;
@@ -93,9 +97,25 @@
*/
private static final int FLAG_LAUNCHER_WAS_ACTIVE_WHILE_AWAKE = 1 << 4;
- /** Whether the device is currently locked. */
+ /**
+ * Whether the device is currently locked.
+ * <ul>
+ * <li>While locked, the taskbar is always stashed.<li/>
+ * <li>Navbar animations on FLAG_DEVICE_LOCKED transitions will get special treatment.</li>
+ * </ul>
+ */
private static final int FLAG_DEVICE_LOCKED = 1 << 5;
+ /**
+ * Whether the complete taskbar is completely hidden (neither visible stashed or unstashed).
+ * This is tracked to allow a nice transition of the taskbar before SysUI forces it away by
+ * hiding the inset.
+ *
+ * This flag is predominanlty set while FLAG_DEVICE_LOCKED is set, thus the taskbar's invisible
+ * resting state while hidden is stashed.
+ */
+ private static final int FLAG_TASKBAR_HIDDEN = 1 << 6;
+
private static final int FLAGS_LAUNCHER_ACTIVE = FLAG_RESUMED | FLAG_TRANSITION_TO_RESUMED;
/** Equivalent to an int with all 1s for binary operation purposes */
private static final int FLAGS_ALL = ~0;
@@ -104,11 +124,21 @@
private static final float TASKBAR_BG_ALPHA_NOT_LAUNCHER_NOT_ALIGNED_DELAY_MULT = 0.33f;
private static final float TASKBAR_BG_ALPHA_LAUNCHER_IS_ALIGNED_DURATION_MULT = 0.25f;
+ /**
+ * Delay for the taskbar fade-in.
+ *
+ * Helps to avoid visual noise when unlocking successfully via SFPS, and the device transitions
+ * to launcher directly. The delay avoids the navbar to become briefly visible. The duration
+ * is the same as in SysUI, see http://shortn/_uNSbDoRUSr.
+ */
+ private static final long TASKBAR_SHOW_DELAY_MS = 250;
+
private final AnimatedFloat mIconAlignment =
new AnimatedFloat(this::onIconAlignmentRatioChanged);
private TaskbarControllers mControllers;
private AnimatedFloat mTaskbarBackgroundAlpha;
+ private AnimatedFloat mTaskbarAlpha;
private AnimatedFloat mTaskbarCornerRoundness;
private MultiProperty mIconAlphaForHome;
private QuickstepLauncher mLauncher;
@@ -117,6 +147,9 @@
private int mState;
private LauncherState mLauncherState = LauncherState.NORMAL;
+ // Time when FLAG_TASKBAR_HIDDEN was last cleared, SystemClock.elapsedRealtime (milliseconds).
+ private long mLastUnlockTimeMs = 0;
+
private @Nullable TaskBarRecentsAnimationListener mTaskBarRecentsAnimationListener;
private boolean mIsAnimatingToLauncher;
@@ -187,6 +220,7 @@
mTaskbarBackgroundAlpha = mControllers.taskbarDragLayerController
.getTaskbarBackgroundAlpha();
+ mTaskbarAlpha = mControllers.taskbarDragLayerController.getTaskbarAlpha();
mTaskbarCornerRoundness = mControllers.getTaskbarCornerRoundness();
mIconAlphaForHome = mControllers.taskbarViewController
.getTaskbarIconAlpha().get(ALPHA_INDEX_HOME);
@@ -279,6 +313,15 @@
boolean isDeviceLocked = hasAnyFlag(systemUiStateFlags, MASK_ANY_SYSUI_LOCKED);
updateStateForFlag(FLAG_DEVICE_LOCKED, isDeviceLocked);
+ // Taskbar is hidden whenever the device is dreaming. The dreaming state includes the
+ // interactive dreams, AoD, screen off. Since the SYSUI_STATE_DEVICE_DREAMING only kicks in
+ // when the device is asleep, the second condition extends ensures that the transition from
+ // and to the WAKEFULNESS_ASLEEP state also hide the taskbar, and improves the taskbar
+ // hide/reveal animation timings.
+ boolean isTaskbarHidden = hasAnyFlag(systemUiStateFlags, SYSUI_STATE_DEVICE_DREAMING)
+ || (systemUiStateFlags & SYSUI_STATE_WAKEFULNESS_MASK) != WAKEFULNESS_AWAKE;
+ updateStateForFlag(FLAG_TASKBAR_HIDDEN, isTaskbarHidden);
+
if (skipAnim) {
applyState(0);
} else {
@@ -406,6 +449,41 @@
AbstractFloatingView.closeAllOpenViews(mControllers.taskbarActivityContext);
}
+ if (hasAnyFlag(changedFlags, FLAG_TASKBAR_HIDDEN) && !hasAnyFlag(FLAG_TASKBAR_HIDDEN)) {
+ // Take note of the current time, as the taskbar is made visible again.
+ mLastUnlockTimeMs = SystemClock.elapsedRealtime();
+ }
+
+ boolean isHidden = hasAnyFlag(FLAG_TASKBAR_HIDDEN);
+ float taskbarAlpha = isHidden ? 0 : 1;
+ if (mTaskbarAlpha.isAnimating() || mTaskbarAlpha.value != taskbarAlpha) {
+ Animator taskbarVisibility = mTaskbarAlpha.animateToValue(taskbarAlpha);
+
+ taskbarVisibility.setDuration(duration);
+ if (isHidden) {
+ // Stash the transient taskbar once the taskbar is not visible. This reduces
+ // visual noise when unlocking the device afterwards.
+ animatorSet.addListener(new AnimatorListenerAdapter() {
+ @Override
+ public void onAnimationEnd(Animator animation) {
+ TaskbarStashController stashController =
+ mControllers.taskbarStashController;
+ stashController.updateAndAnimateTransientTaskbar(
+ /* stash */ true, /* duration */ 0);
+ }
+ });
+ } else {
+ // delay the fade in animation a bit to reduce visual noise when waking up a device
+ // with a fingerprint reader. This should only be done when the device was woken
+ // up via fingerprint reader, however since this information is currently not
+ // available, opting to always delay the fade-in a bit.
+ long durationSinceLastUnlockMs = SystemClock.elapsedRealtime() - mLastUnlockTimeMs;
+ taskbarVisibility.setStartDelay(
+ Math.max(0, TASKBAR_SHOW_DELAY_MS - durationSinceLastUnlockMs));
+ }
+ animatorSet.play(taskbarVisibility);
+ }
+
float backgroundAlpha = isInLauncher && isTaskbarAlignedWithHotseat() ? 0 : 1;
// Don't animate if background has reached desired value.
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarStashController.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarStashController.java
index c43b621..5f11740 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarStashController.java
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarStashController.java
@@ -50,6 +50,7 @@
import android.view.accessibility.AccessibilityManager;
import android.view.animation.Interpolator;
+import androidx.annotation.IntDef;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.annotation.VisibleForTesting;
@@ -68,6 +69,8 @@
import com.android.quickstep.SystemUiProxy;
import java.io.PrintWriter;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
import java.util.StringJoiner;
import java.util.function.IntPredicate;
@@ -184,6 +187,36 @@
// Auto stashes when user has not interacted with the Taskbar after X ms.
private static final long NO_TOUCH_TIMEOUT_TO_STASH_MS = 5000;
+ /**
+ * The default stash animation, morphing the taskbar into the navbar.
+ */
+ private static final int TRANSITION_DEFAULT = 0;
+ /**
+ * Transitioning from launcher to app. Same as TRANSITION_DEFAULT, differs in internal
+ * animation timings.
+ */
+ private static final int TRANSITION_HOME_TO_APP = 1;
+ /**
+ * Fading the navbar in and out, where the taskbar jumpcuts in and out at the very begin/end of
+ * the transition. Used to transition between the hotseat and navbar` without the stash/unstash
+ * transition.
+ */
+ private static final int TRANSITION_HANDLE_FADE = 2;
+ /**
+ * Same as TRANSITION_DEFAULT, but exclusively used during an "navbar unstash to hotseat
+ * animation" bound to the progress of a swipe gesture. It differs from TRANSITION_DEFAULT
+ * by not scaling the height of the taskbar background.
+ */
+ private static final int TRANSITION_UNSTASH_SUW_MANUAL = 3;
+ @Retention(RetentionPolicy.SOURCE)
+ @IntDef(value = {
+ TRANSITION_DEFAULT,
+ TRANSITION_HOME_TO_APP,
+ TRANSITION_HANDLE_FADE,
+ TRANSITION_UNSTASH_SUW_MANUAL,
+ })
+ private @interface StashAnimation {}
+
private final TaskbarActivityContext mActivity;
private final SharedPreferences mPrefs;
private final int mStashedHeight;
@@ -472,9 +505,16 @@
}
/**
- * Stash or unstashes the transient taskbar.
+ * Stash or unstashes the transient taskbar, using the default TASKBAR_STASH_DURATION.
*/
public void updateAndAnimateTransientTaskbar(boolean stash) {
+ updateAndAnimateTransientTaskbar(stash, TASKBAR_STASH_DURATION);
+ }
+
+ /**
+ * Stash or unstashes the transient taskbar.
+ */
+ public void updateAndAnimateTransientTaskbar(boolean stash, long duration) {
if (!DisplayController.isTransientTaskbar(mActivity)) {
return;
}
@@ -553,8 +593,7 @@
createAnimToIsStashed(
/* isStashed= */ false,
placeholderDuration,
- /* animateBg= */ false,
- /* changedFlags=*/ 0);
+ TRANSITION_UNSTASH_SUW_MANUAL);
animation.play(mAnimator);
}
@@ -562,10 +601,15 @@
* 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 animateBg whether the taskbar's background should be animated
+ * @param animationType what transition type to play.
*/
- private void createAnimToIsStashed(boolean isStashed, long duration, boolean animateBg,
- int changedFlags) {
+ private void createAnimToIsStashed(boolean isStashed, long duration,
+ @StashAnimation int animationType) {
+ if (animationType == TRANSITION_UNSTASH_SUW_MANUAL && isStashed) {
+ // The STASH_ANIMATION_SUW_MANUAL must only be used during an unstash animation.
+ Log.e(TAG, "Illegal arguments:Using TRANSITION_UNSTASH_SUW_MANUAL to stash taskbar");
+ }
+
if (mAnimator != null) {
mAnimator.cancel();
}
@@ -591,23 +635,10 @@
return;
}
- // If Hotseat is not the top element during animation to/from Launcher, fade in/out a
- // already stashed Taskbar.
- boolean hotseatTopElement = mControllers.uiController.isHotseatIconOnTopWhenAligned()
- || !hasAnyFlag(changedFlags, FLAG_IN_APP);
- // If transitioning to unlocked device, do not play a stash animation.
- // Keep isUnlockTransition in sync with its counterpart in
- // TaskbarLauncherStateController#onStateChangeApplied.
- boolean isUnlockTransition = hasAnyFlag(changedFlags, FLAG_STASHED_DEVICE_LOCKED)
- && !hasAnyFlag(FLAG_STASHED_DEVICE_LOCKED);
- boolean skipStashAnimation = !hotseatTopElement || isUnlockTransition;
-
if (isTransientTaskbar) {
- createTransientAnimToIsStashed(mAnimator, isStashed, duration, animateBg, changedFlags,
- skipStashAnimation);
+ createTransientAnimToIsStashed(mAnimator, isStashed, duration, animationType);
} else {
- createAnimToIsStashed(mAnimator, isStashed, duration, animateBg, skipStashAnimation,
- stashTranslation);
+ createAnimToIsStashed(mAnimator, isStashed, duration, stashTranslation, animationType);
}
mAnimator.addListener(new AnimatorListenerAdapter() {
@@ -636,7 +667,7 @@
}
private void createAnimToIsStashed(AnimatorSet as, boolean isStashed, long duration,
- boolean animateBg, boolean skipStashAnimation, float stashTranslation) {
+ float stashTranslation, @StashAnimation int animationType) {
AnimatorSet fullLengthAnimatorSet = new AnimatorSet();
// Not exactly half and may overlap. See [first|second]HalfDurationScale below.
AnimatorSet firstHalfAnimatorSet = new AnimatorSet();
@@ -650,12 +681,7 @@
secondHalfDurationScale = 0.5f;
fullLengthAnimatorSet.play(mIconTranslationYForStash.animateToValue(stashTranslation));
- if (animateBg) {
- fullLengthAnimatorSet.play(mTaskbarBackgroundOffset.animateToValue(1));
- } else {
- fullLengthAnimatorSet.addListener(AnimatorListeners.forEndCallback(
- () -> mTaskbarBackgroundOffset.updateValue(1)));
- }
+ fullLengthAnimatorSet.play(mTaskbarBackgroundOffset.animateToValue(1));
firstHalfAnimatorSet.playTogether(
mIconAlphaForStash.animateToValue(0),
@@ -666,7 +692,7 @@
mTaskbarStashedHandleAlpha.animateToValue(1)
);
- if (skipStashAnimation) {
+ if (animationType == TRANSITION_HANDLE_FADE) {
fullLengthAnimatorSet.setInterpolator(INSTANT);
firstHalfAnimatorSet.setInterpolator(INSTANT);
}
@@ -677,6 +703,8 @@
fullLengthAnimatorSet.playTogether(
mIconScaleForStash.animateToValue(1),
mIconTranslationYForStash.animateToValue(0));
+
+ final boolean animateBg = animationType != TRANSITION_UNSTASH_SUW_MANUAL;
if (animateBg) {
fullLengthAnimatorSet.play(mTaskbarBackgroundOffset.animateToValue(0));
} else {
@@ -691,7 +719,7 @@
mIconAlphaForStash.animateToValue(1)
);
- if (skipStashAnimation) {
+ if (animationType == TRANSITION_HANDLE_FADE) {
fullLengthAnimatorSet.setInterpolator(FINAL_FRAME);
secondHalfAnimatorSet.setInterpolator(FINAL_FRAME);
}
@@ -714,18 +742,13 @@
}
private void createTransientAnimToIsStashed(AnimatorSet as, boolean isStashed, long duration,
- boolean animateBg, int changedFlags, boolean skipStashAnimation) {
+ @StashAnimation int animationType) {
Interpolator skipInterpolator = null;
if (isStashed) {
- if (animateBg) {
- play(as, mTaskbarBackgroundOffset.animateToValue(1), 0, duration, EMPHASIZED);
- } else {
- as.addListener(AnimatorListeners.forEndCallback(
- () -> mTaskbarBackgroundOffset.updateValue(1)));
- }
+ play(as, mTaskbarBackgroundOffset.animateToValue(1), 0, duration, EMPHASIZED);
- long alphaStartDelay = duration == 0 ? 0 : (changedFlags == FLAG_IN_APP)
+ long alphaStartDelay = duration == 0 ? 0 : animationType == TRANSITION_HOME_TO_APP
? TASKBAR_STASH_ICON_ALPHA_HOME_TO_APP_START_DELAY
: TASKBAR_STASH_ALPHA_START_DELAY;
long alphaDuration = duration == 0 ? 0 : TASKBAR_STASH_ALPHA_DURATION;
@@ -736,10 +759,11 @@
play(as, mControllers.taskbarSpringOnStashController.createSpringToStash(), 0, duration,
LINEAR);
- if (skipStashAnimation) {
+ if (animationType == TRANSITION_HANDLE_FADE) {
skipInterpolator = INSTANT;
}
} else {
+ final boolean animateBg = animationType != TRANSITION_UNSTASH_SUW_MANUAL;
if (animateBg) {
play(as, mTaskbarBackgroundOffset.animateToValue(0), 0, duration, EMPHASIZED);
} else {
@@ -752,7 +776,7 @@
play(as, mIconAlphaForStash.animateToValue(1), alphaStartDelay, alphaDuration, LINEAR);
play(as, mTaskbarStashedHandleAlpha.animateToValue(0), 0, alphaDuration, LINEAR);
- if (skipStashAnimation) {
+ if (animationType == TRANSITION_HANDLE_FADE) {
skipInterpolator = FINAL_FRAME;
}
}
@@ -928,16 +952,8 @@
hasAnyFlag(systemUiStateFlags, SYSUI_STATE_SCREEN_PINNING));
boolean isLocked = hasAnyFlag(systemUiStateFlags, MASK_ANY_SYSUI_LOCKED);
- boolean wasLocked = hasAnyFlag(FLAG_STASHED_DEVICE_LOCKED);
updateStateForFlag(FLAG_STASHED_DEVICE_LOCKED, isLocked);
- if (isLocked && !wasLocked && DisplayController.isTransientTaskbar(mActivity)) {
- // Stash the transient taskbar when locking the device. This improves the transition
- // to AoD (otherwise the taskbar stays a bit too long above the collapsing AoD scrim),
- // and ensures the taskar state is reset when unlocking the device afterwards.
- updateStateForFlag(FLAG_STASHED_IN_APP_AUTO, true);
- }
-
// Only update FLAG_STASHED_IN_APP_IME when system gesture is not in progress.
mIsImeShowing = hasAnyFlag(systemUiStateFlags, SYSUI_STATE_IME_SHOWING);
mIsImeSwitcherShowing = hasAnyFlag(systemUiStateFlags, SYSUI_STATE_IME_SWITCHER_SHOWING);
@@ -1150,7 +1166,7 @@
private final IntPredicate mStashCondition;
private boolean mIsStashed;
- private boolean mIsHotseatIconOnTopWhenAligned;
+ private @StashAnimation int mLastStartedTransitionType = TRANSITION_DEFAULT;
private int mPrevFlags;
StatePropertyHolder(IntPredicate stashCondition) {
@@ -1182,28 +1198,64 @@
onStateChangeApplied(changedFlags);
mPrevFlags = flags;
}
- boolean isHotseatIconOnTopWhenAligned =
- mControllers.uiController.isHotseatIconOnTopWhenAligned();
- // If an animation has started and mIsHotseatIconOnTopWhenAligned is changed, we need
- // to restart the animation with new parameters.
- if (mIsStashed != isStashed
- || (mIsHotseatIconOnTopWhenAligned != isHotseatIconOnTopWhenAligned
- && mAnimator != null && mAnimator.isStarted())) {
+
+ @StashAnimation int animationType = computeTransitionType(changedFlags);
+
+ // Allow re-starting animation if upgrading from default animation type, otherwise
+ // stick with the already started transition.
+ boolean transitionTypeChanged = mAnimator != null && mAnimator.isStarted()
+ && mLastStartedTransitionType == TRANSITION_DEFAULT
+ && animationType != TRANSITION_DEFAULT;
+
+ if (mIsStashed != isStashed || transitionTypeChanged) {
if (TestProtocol.sDebugTracing) {
Log.d(TestProtocol.TASKBAR_IN_APP_STATE, String.format(
- "setState: mIsStashed=%b, isStashed=%b, duration=%d",
+ "setState: mIsStashed=%b, isStashed=%b, "
+ + "mAnimationType=%d, animationType=%d, duration=%d",
mIsStashed,
isStashed,
+ mLastStartedTransitionType,
+ animationType,
duration));
}
mIsStashed = isStashed;
- mIsHotseatIconOnTopWhenAligned = isHotseatIconOnTopWhenAligned;
+ mLastStartedTransitionType = animationType;
// This sets mAnimator.
- createAnimToIsStashed(mIsStashed, duration, /* animateBg= */ true, changedFlags);
+ createAnimToIsStashed(mIsStashed, duration, animationType);
return mAnimator;
}
return null;
}
+
+ private @StashAnimation int computeTransitionType(int changedFlags) {
+ boolean hotseatHiddenDuringAppLaunch =
+ !mControllers.uiController.isHotseatIconOnTopWhenAligned()
+ && hasAnyFlag(changedFlags, FLAG_IN_APP);
+ if (hotseatHiddenDuringAppLaunch) {
+ // When launching an app from the all-apps drawer, the hotseat is hidden behind the
+ // drawer. In this case, the navbar must just fade in, without a stash transition,
+ // as the taskbar stash animation would otherwise be visible above the all-apps
+ // drawer once the hotseat is detached.
+ return TRANSITION_HANDLE_FADE;
+ }
+
+ boolean isUnlockTransition = hasAnyFlag(changedFlags, FLAG_STASHED_DEVICE_LOCKED)
+ && !hasAnyFlag(FLAG_STASHED_DEVICE_LOCKED);
+ if (isUnlockTransition) {
+ // When transitioning to unlocked device, the hotseat will already be visible on
+ // the homescreen, thus do not play an un-stash animation.
+ // Keep isUnlockTransition in sync with its counterpart in
+ // TaskbarLauncherStateController#onStateChangeApplied.
+ return TRANSITION_HANDLE_FADE;
+ }
+
+ boolean homeToApp = hasAnyFlag(changedFlags, FLAG_IN_APP) && hasAnyFlag(FLAG_IN_APP);
+ if (homeToApp) {
+ return TRANSITION_HOME_TO_APP;
+ }
+
+ return TRANSITION_DEFAULT;
+ }
}
}