Merge "Do not perform invisible transitions while the screen is off." into tm-qpr-dev (42a8fe91) · Commits · e / os / android_packages_apps_Trebuchet

quickstep/src/com/android/launcher3/taskbar/LauncherTaskbarUIController.java

+8 −12

Original line number	Diff line number	Diff line
		@@ -84,7 +84,6 @@ public class LauncherTaskbarUIController extends TaskbarUIController {
		};

		// Initialized in init.
		private TaskbarKeyguardController mKeyguardController;
		private final TaskbarLauncherStateController
		mTaskbarLauncherStateController = new TaskbarLauncherStateController();

		@@ -99,11 +98,12 @@ public class LauncherTaskbarUIController extends TaskbarUIController {
		mTaskbarLauncherStateController.init(mControllers, mLauncher);

		mLauncher.setTaskbarUIController(this);
		mKeyguardController = taskbarControllers.taskbarKeyguardController;

		onLauncherResumedOrPaused(mLauncher.hasBeenResumed(), true /* fromInit */);

		onStashedInAppChanged(mLauncher.getDeviceProfile());
		mTaskbarLauncherStateController.onChangeScreenState(
		mControllers.getSharedState().sysuiStateFlags, true /* fromInit */);
		mLauncher.addOnDeviceProfileChangeListener(mOnDeviceProfileChangeListener);
		}

		@@ -121,7 +121,7 @@ public class LauncherTaskbarUIController extends TaskbarUIController {
		@Override
		protected boolean isTaskbarTouchable() {
		return !(mTaskbarLauncherStateController.isAnimatingToLauncher()
		&& mTaskbarLauncherStateController.goingToAlignedLauncherState());
		&& mTaskbarLauncherStateController.isTaskbarAlignedWithHotseat());
		}

		public void setShouldDelayLauncherStateAnim(boolean shouldDelayLauncherStateAnim) {
		@@ -169,15 +169,6 @@ public class LauncherTaskbarUIController extends TaskbarUIController {
		@Nullable
		private Animator onLauncherResumedOrPaused(
		boolean isResumed, boolean fromInit, boolean startAnimation, int duration) {
		if (mKeyguardController.isScreenOff()) {
		if (!isResumed) {
		return null;
		} else {
		// Resuming implicitly means device unlocked
		mKeyguardController.setScreenOn();
		}
		}

		if (ENABLE_SHELL_TRANSITIONS && isResumed
		&& !mLauncher.getStateManager().getState().isTaskbarAlignedWithHotseat(mLauncher)) {
		// Launcher is resumed, but in a state where taskbar is still independent, so
		@@ -328,6 +319,11 @@ public class LauncherTaskbarUIController extends TaskbarUIController {
		mTaskbarLauncherStateController.applyState();
		}

		@Override
		public void onChangeScreenState(int screenState) {
		mTaskbarLauncherStateController.onChangeScreenState(screenState, false /* fromInit */);
		}

		@Override
		public boolean isIconAlignedWithHotseat() {
		return mTaskbarLauncherStateController.isIconAlignedWithHotseat();

quickstep/src/com/android/launcher3/taskbar/TaskbarActivityContext.java

+4 −0

Original line number	Diff line number	Diff line
		@@ -32,6 +32,7 @@ import static com.android.launcher3.taskbar.TaskbarManager.FLAG_HIDE_NAVBAR_WIND
		import static com.android.launcher3.testing.shared.ResourceUtils.getBoolByName;
		import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_NOTIFICATION_PANEL_EXPANDED;
		import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_QUICK_SETTINGS_EXPANDED;
		import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_SCREEN_STATE_MASK;
		import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_VOICE_INTERACTION_WINDOW_SHOWING;

		import android.animation.AnimatorSet;
		@@ -589,6 +590,9 @@ public class TaskbarActivityContext extends BaseTaskbarContext {
		mControllers.taskbarForceVisibleImmersiveController.updateSysuiFlags(systemUiStateFlags);
		mControllers.voiceInteractionWindowController.setIsVoiceInteractionWindowVisible(
		(systemUiStateFlags & SYSUI_STATE_VOICE_INTERACTION_WINDOW_SHOWING) != 0, fromInit);

		mControllers.uiController.onChangeScreenState(
		systemUiStateFlags & SYSUI_STATE_SCREEN_STATE_MASK);
		}

		/**

quickstep/src/com/android/launcher3/taskbar/TaskbarControllers.java

+0 −1

Original line number	Diff line number	Diff line
		@@ -213,7 +213,6 @@ public class TaskbarControllers {
		uiController.onDestroy();
		rotationButtonController.onDestroy();
		taskbarDragLayerController.onDestroy();
		taskbarKeyguardController.onDestroy();
		taskbarUnfoldAnimationController.onDestroy();
		taskbarViewController.onDestroy();
		stashedHandleViewController.onDestroy();

quickstep/src/com/android/launcher3/taskbar/TaskbarKeyguardController.java

+23 −34

Original line number	Diff line number	Diff line
		package com.android.launcher3.taskbar;

		import static com.android.launcher3.AbstractFloatingView.TYPE_ALL;
		import static com.android.systemui.shared.system.QuickStepContract.SCREEN_STATE_OFF;
		import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_BACK_DISABLED;
		import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_BOUNCER_SHOWING;
		import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_DEVICE_DOZING;
		import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_HOME_DISABLED;
		import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_OVERVIEW_DISABLED;
		import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_SCREEN_ON;
		import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_SCREEN_STATE_MASK;
		import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_STATUS_BAR_KEYGUARD_SHOWING;
		import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_STATUS_BAR_KEYGUARD_SHOWING_OCCLUDED;

		import android.app.KeyguardManager;

		import com.android.launcher3.AbstractFloatingView;
		import com.android.launcher3.util.ScreenOnTracker;
		import com.android.launcher3.util.ScreenOnTracker.ScreenOnListener;
		import com.android.systemui.shared.system.QuickStepContract;

		import java.io.PrintWriter;
		@@ -23,36 +24,35 @@ import java.io.PrintWriter;
		*/
		public class TaskbarKeyguardController implements TaskbarControllers.LoggableTaskbarController {

		private static final int KEYGUARD_SYSUI_FLAGS = SYSUI_STATE_BOUNCER_SHOWING \|
		SYSUI_STATE_STATUS_BAR_KEYGUARD_SHOWING \| SYSUI_STATE_DEVICE_DOZING \|
		SYSUI_STATE_OVERVIEW_DISABLED \| SYSUI_STATE_HOME_DISABLED \|
		SYSUI_STATE_BACK_DISABLED \| SYSUI_STATE_STATUS_BAR_KEYGUARD_SHOWING_OCCLUDED;
		private static final int KEYGUARD_SYSUI_FLAGS = SYSUI_STATE_BOUNCER_SHOWING
		\| SYSUI_STATE_STATUS_BAR_KEYGUARD_SHOWING \| SYSUI_STATE_DEVICE_DOZING
		\| SYSUI_STATE_OVERVIEW_DISABLED \| SYSUI_STATE_HOME_DISABLED
		\| SYSUI_STATE_BACK_DISABLED \| SYSUI_STATE_STATUS_BAR_KEYGUARD_SHOWING_OCCLUDED
		\| SYSUI_STATE_SCREEN_STATE_MASK;

		private final ScreenOnListener mScreenOnListener;
		private final TaskbarActivityContext mContext;
		private int mKeyguardSysuiFlags;
		private boolean mBouncerShowing;
		private NavbarButtonsViewController mNavbarButtonsViewController;
		private final KeyguardManager mKeyguardManager;
		private boolean mIsScreenOff;

		public TaskbarKeyguardController(TaskbarActivityContext context) {
		mContext = context;
		mScreenOnListener = isOn -> {
		if (!isOn) {
		mIsScreenOff = true;
		AbstractFloatingView.closeOpenViews(mContext, false, TYPE_ALL);
		}
		};
		mKeyguardManager = mContext.getSystemService(KeyguardManager.class);
		}

		public void init(NavbarButtonsViewController navbarButtonUIController) {
		mNavbarButtonsViewController = navbarButtonUIController;
		ScreenOnTracker.INSTANCE.get(mContext).addListener(mScreenOnListener);
		}

		public void updateStateForSysuiFlags(int systemUiStateFlags) {
		int interestingKeyguardFlags = systemUiStateFlags & KEYGUARD_SYSUI_FLAGS;
		if (interestingKeyguardFlags == mKeyguardSysuiFlags) {
		// No change in keyguard relevant flags
		return;
		}
		mKeyguardSysuiFlags = interestingKeyguardFlags;

		boolean bouncerShowing = (systemUiStateFlags & SYSUI_STATE_BOUNCER_SHOWING) != 0;
		boolean keyguardShowing = (systemUiStateFlags & SYSUI_STATE_STATUS_BAR_KEYGUARD_SHOWING)
		!= 0;
		@@ -60,11 +60,6 @@ public class TaskbarKeyguardController implements TaskbarControllers.LoggableTas
		(systemUiStateFlags & SYSUI_STATE_STATUS_BAR_KEYGUARD_SHOWING_OCCLUDED) != 0;
		boolean dozing = (systemUiStateFlags & SYSUI_STATE_DEVICE_DOZING) != 0;

		int interestingKeyguardFlags = systemUiStateFlags & KEYGUARD_SYSUI_FLAGS;
		if (interestingKeyguardFlags == mKeyguardSysuiFlags) {
		return;
		}
		mKeyguardSysuiFlags = interestingKeyguardFlags;

		mBouncerShowing = bouncerShowing;

		@@ -72,17 +67,15 @@ public class TaskbarKeyguardController implements TaskbarControllers.LoggableTas
		keyguardOccluded);
		updateIconsForBouncer();

		if (keyguardShowing) {
		AbstractFloatingView.closeOpenViews(mContext, true, TYPE_ALL);
		}
		}
		boolean screenOffOrTransitioningOff = (systemUiStateFlags & SYSUI_STATE_SCREEN_ON) == 0;
		boolean closeFloatingViews = keyguardShowing \|\| screenOffOrTransitioningOff;

		public boolean isScreenOff() {
		return mIsScreenOff;
		if (closeFloatingViews) {
		// animate the closing of the views, unless the screen is already fully turned off.
		boolean animateViewClosing =
		(systemUiStateFlags & SYSUI_STATE_SCREEN_STATE_MASK) != SCREEN_STATE_OFF;
		AbstractFloatingView.closeOpenViews(mContext, animateViewClosing, TYPE_ALL);
		}

		public void setScreenOn() {
		mIsScreenOff = false;
		}

		/**
		@@ -95,9 +88,6 @@ public class TaskbarKeyguardController implements TaskbarControllers.LoggableTas
		mNavbarButtonsViewController.setBackForBouncer(showBackForBouncer);
		}

		public void onDestroy() {
		ScreenOnTracker.INSTANCE.get(mContext).removeListener(mScreenOnListener);
		}

		@Override
		public void dumpLogs(String prefix, PrintWriter pw) {
		@@ -106,6 +96,5 @@ public class TaskbarKeyguardController implements TaskbarControllers.LoggableTas
		pw.println(prefix + "\tmKeyguardSysuiFlags=" + QuickStepContract.getSystemUiStateString(
		mKeyguardSysuiFlags));
		pw.println(prefix + "\tmBouncerShowing=" + mBouncerShowing);
		pw.println(prefix + "\tmIsScreenOff=" + mIsScreenOff);
		}
		}

quickstep/src/com/android/launcher3/taskbar/TaskbarLauncherStateController.java

+131 −61

Original line number	Diff line number	Diff line
		@@ -18,7 +18,10 @@ package com.android.launcher3.taskbar;
		import static com.android.launcher3.taskbar.TaskbarStashController.FLAG_IN_APP;
		import static com.android.launcher3.taskbar.TaskbarStashController.FLAG_IN_STASHED_LAUNCHER_STATE;
		import static com.android.launcher3.taskbar.TaskbarViewController.ALPHA_INDEX_HOME;
		import static com.android.launcher3.util.FlagDebugUtils.appendFlag;
		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_SCREEN_ON;

		import android.animation.Animator;
		import android.animation.AnimatorListenerAdapter;
		@@ -58,11 +61,38 @@ import java.util.StringJoiner;
		private static final String TAG = TaskbarLauncherStateController.class.getSimpleName();
		private static final boolean DEBUG = false;

		/** Launcher activity is resumed and focused. */
		public static final int FLAG_RESUMED = 1 << 0;
		public static final int FLAG_RECENTS_ANIMATION_RUNNING = 1 << 1;
		public static final int FLAG_TRANSITION_STATE_RUNNING = 1 << 2;

		private static final int FLAGS_LAUNCHER = FLAG_RESUMED \| FLAG_RECENTS_ANIMATION_RUNNING;
		/**
		* A external transition / animation is running that will result in FLAG_RESUMED being set.
		**/
		public static final int FLAG_TRANSITION_TO_RESUMED = 1 << 1;

		/**
		* Set while the launcher state machine is performing a state transition, see {@link
		* StateManager.StateListener}.
		*/
		public static final int FLAG_LAUNCHER_IN_STATE_TRANSITION = 1 << 2;

		/**
		* Whether the screen is currently on, or is transitioning to be on.
		*
		* This is cleared as soon as the screen begins to transition off.
		*/
		private static final int FLAG_SCREEN_ON = 1 << 3;

		/**
		* Captures whether the launcher was active at the time the FLAG_SCREEN_ON was cleared.
		* Always cleared when FLAG_SCREEN_ON is set.
		* <p>
		* FLAG_RESUMED will be cleared when the screen is off, since all apps get paused at this point.
		* Thus, this flag indicates whether the launcher will be shown when the screen gets turned on
		* again.
		*/
		private static final int FLAG_LAUNCHER_ACTIVE_AT_SCREEN_OFF = 1 << 4;

		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;

		@@ -115,12 +145,13 @@ import java.util.StringJoiner;
		@Override
		public void onStateTransitionStart(LauncherState toState) {
		if (toState != mLauncherState) {
		// Treat FLAG_TRANSITION_STATE_RUNNING as a changed flag even if a previous
		// state transition was already running, so we update the new target.
		mPrevState &= ~FLAG_TRANSITION_STATE_RUNNING;
		// Treat FLAG_LAUNCHER_IN_STATE_TRANSITION as a changed flag even if a
		// previous state transition was already running, so we update the new
		// target.
		mPrevState &= ~FLAG_LAUNCHER_IN_STATE_TRANSITION;
		mLauncherState = toState;
		}
		updateStateForFlag(FLAG_TRANSITION_STATE_RUNNING, true);
		updateStateForFlag(FLAG_LAUNCHER_IN_STATE_TRANSITION, true);
		if (!mShouldDelayLauncherStateAnim) {
		if (toState == LauncherState.NORMAL) {
		applyState(QuickstepTransitionManager.TASKBAR_TO_HOME_DURATION);
		@@ -133,7 +164,7 @@ import java.util.StringJoiner;
		@Override
		public void onStateTransitionComplete(LauncherState finalState) {
		mLauncherState = finalState;
		updateStateForFlag(FLAG_TRANSITION_STATE_RUNNING, false);
		updateStateForFlag(FLAG_LAUNCHER_IN_STATE_TRANSITION, false);
		applyState();
		boolean disallowLongClick = finalState == LauncherState.OVERVIEW_SPLIT_SELECT;
		com.android.launcher3.taskbar.Utilities.setOverviewDragState(
		@@ -159,9 +190,6 @@ import java.util.StringJoiner;
		resetIconAlignment();

		mLauncher.getStateManager().addStateListener(mStateListener);

		// Initialize to the current launcher state
		updateStateForFlag(FLAG_RESUMED, launcher.hasBeenResumed());
		mLauncherState = launcher.getStateManager().getState();
		applyState(0);

		@@ -182,6 +210,12 @@ import java.util.StringJoiner;
		mLauncher.removeOnDeviceProfileChangeListener(mOnDeviceProfileChangeListener);
		}

		/**
		* Creates a transition animation to the launcher activity.
		*
		* Warning: the resulting animation must be played, since this method has side effects on this
		* controller's state.
		*/
		public Animator createAnimToLauncher(@NonNull LauncherState toState,
		@NonNull RecentsAnimationCallbacks callbacks, long duration) {
		// If going to overview, stash the task bar
		@@ -197,7 +231,7 @@ import java.util.StringJoiner;
		}
		stashController.updateStateForFlag(FLAG_IN_APP, false);

		updateStateForFlag(FLAG_RECENTS_ANIMATION_RUNNING, true);
		updateStateForFlag(FLAG_TRANSITION_TO_RESUMED, true);
		animatorSet.play(stashController.createApplyStateAnimator(duration));
		animatorSet.play(applyState(duration, false));

		@@ -225,6 +259,24 @@ import java.util.StringJoiner;
		mShouldDelayLauncherStateAnim = shouldDelayLauncherStateAnim;
		}

		/** Screen state changed, see QuickStepContract.SCREEN_STATE_* values. */
		public void onChangeScreenState(int screenState, boolean fromInit) {
		final boolean prevScreenIsOn = hasAnyFlag(FLAG_SCREEN_ON);
		final boolean currScreenIsOn = hasAnyFlag(screenState, SYSUI_STATE_SCREEN_ON);

		if (prevScreenIsOn == currScreenIsOn) return;

		updateStateForFlag(FLAG_SCREEN_ON, currScreenIsOn);
		updateStateForFlag(FLAG_LAUNCHER_ACTIVE_AT_SCREEN_OFF,
		prevScreenIsOn && hasAnyFlag(FLAGS_LAUNCHER_ACTIVE));

		if (fromInit) {
		applyState(0);
		} else {
		applyState();
		}
		}

		/**
		* Updates the proper flag to change the state of the task bar.
		*
		@@ -269,6 +321,19 @@ import java.util.StringJoiner;
		if (mPrevState == null \|\| mPrevState != mState) {
		// If this is our initial state, treat all flags as changed.
		int changedFlags = mPrevState == null ? FLAGS_ALL : mPrevState ^ mState;

		if (DEBUG) {
		String stateString;
		if (mPrevState == null) {
		stateString = getStateString(mState) + "(initial update)";
		} else {
		stateString = formatFlagChange(mState, mPrevState,
		TaskbarLauncherStateController::getStateString);
		}
		Log.d(TAG, "applyState: " + stateString
		+ ", duration: " + duration
		+ ", start: " + start);
		}
		mPrevState = mState;
		animator = onStateChangeApplied(changedFlags, duration, start);
		}
		@@ -276,26 +341,23 @@ import java.util.StringJoiner;
		}

		private Animator onStateChangeApplied(int changedFlags, long duration, boolean start) {
		final boolean goingToLauncher = isInLauncher();
		final boolean isInLauncher = isInLauncher();
		final boolean isIconAlignedWithHotseat = isIconAlignedWithHotseat();
		final float toAlignment = isIconAlignedWithHotseat ? 1 : 0;
		boolean handleOpenFloatingViews = false;
		if (DEBUG) {
		Log.d(TAG, "onStateChangeApplied - mState: " + getStateString(mState)
		+ ", changedFlags: " + getStateString(changedFlags)
		+ ", goingToLauncher: " + goingToLauncher
		Log.d(TAG, "onStateChangeApplied - isInLauncher: " + isInLauncher
		+ ", mLauncherState: " + mLauncherState
		+ ", toAlignment: " + toAlignment);
		}
		AnimatorSet animatorSet = new AnimatorSet();

		// Add the state animation first to ensure FLAG_IN_STASHED_LAUNCHER_STATE is set and we can
		// determine whether goingToUnstashedLauncherStateChanged.
		if (hasAnyFlag(changedFlags, FLAG_TRANSITION_STATE_RUNNING)) {
		boolean committed = !hasAnyFlag(FLAG_TRANSITION_STATE_RUNNING);
		playStateTransitionAnim(animatorSet, duration, committed);
		if (hasAnyFlag(changedFlags, FLAG_LAUNCHER_IN_STATE_TRANSITION)) {
		boolean launcherTransitionCompleted = !hasAnyFlag(FLAG_LAUNCHER_IN_STATE_TRANSITION);
		playStateTransitionAnim(animatorSet, duration, launcherTransitionCompleted);

		if (committed && mLauncherState == LauncherState.QUICK_SWITCH_FROM_HOME) {
		if (launcherTransitionCompleted
		&& mLauncherState == LauncherState.QUICK_SWITCH_FROM_HOME) {
		// We're about to be paused, set immediately to ensure seamless handoff.
		updateStateForFlag(FLAG_RESUMED, false);
		applyState(0 /* duration */);
		@@ -306,37 +368,37 @@ import java.util.StringJoiner;
		}
		}

		if (hasAnyFlag(changedFlags, FLAGS_LAUNCHER)) {
		if (hasAnyFlag(changedFlags, FLAGS_LAUNCHER_ACTIVE)) {
		animatorSet.addListener(new AnimatorListenerAdapter() {
		@Override
		public void onAnimationEnd(Animator animation) {
		mIsAnimatingToLauncher = false;
		}

		@Override
		public void onAnimationStart(Animator animation) {
		mIsAnimatingToLauncher = goingToLauncher;
		mIsAnimatingToLauncher = isInLauncher;

		TaskbarStashController stashController =
		mControllers.taskbarStashController;
		if (DEBUG) {
		Log.d(TAG, "onAnimationStart - FLAG_IN_APP: " + !goingToLauncher);
		Log.d(TAG, "onAnimationStart - FLAG_IN_APP: " + !isInLauncher);
		}
		stashController.updateStateForFlag(FLAG_IN_APP, !goingToLauncher);
		stashController.updateStateForFlag(FLAG_IN_APP, !isInLauncher);
		stashController.applyState(duration);
		}

		@Override
		public void onAnimationEnd(Animator animation) {
		mIsAnimatingToLauncher = false;
		}
		});

		// Handle closing open popups when going home/overview
		handleOpenFloatingViews = true;
		}
		if (handleOpenFloatingViews && goingToLauncher) {

		if (handleOpenFloatingViews && isInLauncher) {
		AbstractFloatingView.closeAllOpenViews(mControllers.taskbarActivityContext);
		}

		float backgroundAlpha =
		goingToLauncher && mLauncherState.isTaskbarAlignedWithHotseat(mLauncher)
		? 0 : 1;
		float backgroundAlpha = isInLauncher && isTaskbarAlignedWithHotseat() ? 0 : 1;

		// Don't animate if background has reached desired value.
		if (mTaskbarBackgroundAlpha.isAnimating()
		\|\| mTaskbarBackgroundAlpha.value != backgroundAlpha) {
		@@ -347,21 +409,20 @@ import java.util.StringJoiner;
		+ " -> " + backgroundAlpha + ": " + duration);
		}

		boolean goingToLauncherIconNotAligned = goingToLauncher && !isIconAlignedWithHotseat;
		boolean notGoingToLauncherIconNotAligned = !goingToLauncher
		&& !isIconAlignedWithHotseat;
		boolean goingToLauncherIconIsAligned = goingToLauncher && isIconAlignedWithHotseat;
		boolean isInLauncherIconNotAligned = isInLauncher && !isIconAlignedWithHotseat;
		boolean notInLauncherIconNotAligned = !isInLauncher && !isIconAlignedWithHotseat;
		boolean isInLauncherIconIsAligned = isInLauncher && isIconAlignedWithHotseat;

		float startDelay = 0;
		// We want to delay the background from fading in so that the icons have time to move
		// into the bounds of the background before it appears.
		if (goingToLauncherIconNotAligned) {
		if (isInLauncherIconNotAligned) {
		startDelay = duration * TASKBAR_BG_ALPHA_LAUNCHER_NOT_ALIGNED_DELAY_MULT;
		} else if (notGoingToLauncherIconNotAligned) {
		} else if (notInLauncherIconNotAligned) {
		startDelay = duration * TASKBAR_BG_ALPHA_NOT_LAUNCHER_NOT_ALIGNED_DELAY_MULT;
		}
		float newDuration = duration - startDelay;
		if (goingToLauncherIconIsAligned) {
		if (isInLauncherIconIsAligned) {
		// Make the background fade out faster so that it is gone by the time the
		// icons move outside of the bounds of the background.
		newDuration = duration * TASKBAR_BG_ALPHA_LAUNCHER_IS_ALIGNED_DURATION_MULT;
		@@ -373,7 +434,8 @@ import java.util.StringJoiner;
		animatorSet.play(taskbarBackgroundAlpha);
		}

		float cornerRoundness = goingToLauncher ? 0 : 1;
		float cornerRoundness = isInLauncher ? 0 : 1;

		// Don't animate if corner roundness has reached desired value.
		if (mTaskbarCornerRoundness.isAnimating()
		\|\| mTaskbarCornerRoundness.value != cornerRoundness) {
		@@ -412,8 +474,12 @@ import java.util.StringJoiner;
		return animatorSet;
		}

		/** Returns whether we're going to a state where taskbar icons should align with launcher. */
		public boolean goingToAlignedLauncherState() {
		/**
		* Whether the taskbar is aligned with the hotseat in the current/target launcher state.
		*
		* This refers to the intended state - a transition to this state might be in progress.
		*/
		public boolean isTaskbarAlignedWithHotseat() {
		return mLauncherState.isTaskbarAlignedWithHotseat(mLauncher);
		}

		@@ -481,8 +547,13 @@ import java.util.StringJoiner;
		}
		}

		/** Whether the launcher is considered active. */
		private boolean isInLauncher() {
		return (mState & FLAGS_LAUNCHER) != 0;
		if (hasAnyFlag(FLAG_SCREEN_ON)) {
		return hasAnyFlag(FLAGS_LAUNCHER_ACTIVE);
		} else {
		return hasAnyFlag(FLAG_LAUNCHER_ACTIVE_AT_SCREEN_OFF);
		}
		}

		/**
		@@ -509,7 +580,8 @@ import java.util.StringJoiner;
		if (firstFrameVisChanged && mCanSyncViews && !Utilities.isRunningInTestHarness()) {
		ViewRootSync.synchronizeNextDraw(mLauncher.getHotseat(),
		mControllers.taskbarActivityContext.getDragLayer(),
		() -> {});
		() -> {
		});
		}
		}

		@@ -562,7 +634,7 @@ import java.util.StringJoiner;

		// Update the resumed state immediately to ensure a seamless handoff
		boolean launcherResumed = !finishedToApp;
		updateStateForFlag(FLAG_RECENTS_ANIMATION_RUNNING, false);
		updateStateForFlag(FLAG_TRANSITION_TO_RESUMED, false);
		updateStateForFlag(FLAG_RESUMED, launcherResumed);
		applyState();

		@@ -576,17 +648,15 @@ import java.util.StringJoiner;
		}

		private static String getStateString(int flags) {
		StringJoiner str = new StringJoiner("\|");
		if ((flags & FLAG_RESUMED) != 0) {
		str.add("FLAG_RESUMED");
		}
		if ((flags & FLAG_RECENTS_ANIMATION_RUNNING) != 0) {
		str.add("FLAG_RECENTS_ANIMATION_RUNNING");
		}
		if ((flags & FLAG_TRANSITION_STATE_RUNNING) != 0) {
		str.add("FLAG_TRANSITION_STATE_RUNNING");
		}
		return str.toString();
		StringJoiner result = new StringJoiner("\|");
		appendFlag(result, flags, FLAG_RESUMED, "resumed");
		appendFlag(result, flags, FLAG_TRANSITION_TO_RESUMED, "transition_to_resumed");
		appendFlag(result, flags, FLAG_LAUNCHER_IN_STATE_TRANSITION,
		"launcher_in_state_transition");
		appendFlag(result, flags, FLAG_SCREEN_ON, "screen_on");
		appendFlag(result, flags, FLAG_LAUNCHER_ACTIVE_AT_SCREEN_OFF,
		"launcher_active_at_screen_off");
		return result.toString();
		}

		protected void dumpLogs(String prefix, PrintWriter pw) {