Merge "Update start radius for reveal animation to match spec." into tm-qpr-dev
diff --git a/quickstep/res/values/dimens.xml b/quickstep/res/values/dimens.xml
index 225bdcc..599095b 100644
--- a/quickstep/res/values/dimens.xml
+++ b/quickstep/res/values/dimens.xml
@@ -300,6 +300,8 @@
<dimen name="transient_taskbar_key_shadow_distance">10dp</dimen>
<dimen name="transient_taskbar_stashed_size">32dp</dimen>
<dimen name="transient_taskbar_all_apps_button_translation_x_offset">4dp</dimen>
+ <dimen name="transient_taskbar_stash_spring_velocity_dp_per_s">400dp</dimen>
+
<!-- An additional touch slop to prevent x-axis movement during the swipe up to show taskbar -->
<dimen name="transient_taskbar_clamped_offset_bound">16dp</dimen>
<!-- Taskbar swipe up thresholds -->
diff --git a/quickstep/src/com/android/launcher3/taskbar/BaseTaskbarContext.java b/quickstep/src/com/android/launcher3/taskbar/BaseTaskbarContext.java
index 48352a2..331184a 100644
--- a/quickstep/src/com/android/launcher3/taskbar/BaseTaskbarContext.java
+++ b/quickstep/src/com/android/launcher3/taskbar/BaseTaskbarContext.java
@@ -65,4 +65,10 @@
/** Callback invoked when a popup is shown or closed within this context. */
public abstract void onPopupVisibilityChanged(boolean isVisible);
+
+ /**
+ * Callback invoked when user attempts to split the screen through a long-press menu in Taskbar
+ * or AllApps.
+ */
+ public abstract void onSplitScreenMenuButtonClicked();
}
diff --git a/quickstep/src/com/android/launcher3/taskbar/LauncherTaskbarUIController.java b/quickstep/src/com/android/launcher3/taskbar/LauncherTaskbarUIController.java
index 95fea3e..fbf78ae 100644
--- a/quickstep/src/com/android/launcher3/taskbar/LauncherTaskbarUIController.java
+++ b/quickstep/src/com/android/launcher3/taskbar/LauncherTaskbarUIController.java
@@ -66,9 +66,10 @@
public static final int WIDGETS_PAGE_PROGRESS_INDEX = 2;
public static final int SYSUI_SURFACE_PROGRESS_INDEX = 3;
- private static final int DISPLAY_PROGRESS_COUNT = 4;
+ public static final int DISPLAY_PROGRESS_COUNT = 4;
- private final AnimatedFloat mTaskbarInAppDisplayProgress = new AnimatedFloat();
+ private final AnimatedFloat mTaskbarInAppDisplayProgress = new AnimatedFloat(
+ this::onInAppDisplayProgressChanged);
private final MultiPropertyFactory<AnimatedFloat> mTaskbarInAppDisplayProgressMultiProp =
new MultiPropertyFactory<>(mTaskbarInAppDisplayProgress,
AnimatedFloat.VALUE, DISPLAY_PROGRESS_COUNT, Float::max);
@@ -84,7 +85,6 @@
};
// Initialized in init.
- private TaskbarKeyguardController mKeyguardController;
private final TaskbarLauncherStateController
mTaskbarLauncherStateController = new TaskbarLauncherStateController();
@@ -99,12 +99,19 @@
mTaskbarLauncherStateController.init(mControllers, mLauncher);
mLauncher.setTaskbarUIController(this);
- mKeyguardController = taskbarControllers.taskbarKeyguardController;
onLauncherResumedOrPaused(mLauncher.hasBeenResumed(), true /* fromInit */);
onStashedInAppChanged(mLauncher.getDeviceProfile());
+ mTaskbarLauncherStateController.updateStateForSysuiFlags(
+ mControllers.getSharedState().sysuiStateFlags, true /* fromInit */);
mLauncher.addOnDeviceProfileChangeListener(mOnDeviceProfileChangeListener);
+
+ // Restore the in-app display progress from before Taskbar was recreated.
+ float[] prevProgresses = mControllers.getSharedState().inAppDisplayProgressMultiPropValues;
+ for (int i = 0; i < prevProgresses.length; i++) {
+ mTaskbarInAppDisplayProgressMultiProp.get(i).setValue(prevProgresses[i]);
+ }
}
@Override
@@ -118,10 +125,22 @@
updateTaskTransitionSpec(true);
}
+ private void onInAppDisplayProgressChanged() {
+ if (mControllers != null) {
+ // Update our shared state so we can restore it if taskbar gets recreated.
+ for (int i = 0; i < DISPLAY_PROGRESS_COUNT; i++) {
+ mControllers.getSharedState().inAppDisplayProgressMultiPropValues[i] =
+ mTaskbarInAppDisplayProgressMultiProp.get(i).getValue();
+ }
+ // Ensure nav buttons react to our latest state if necessary.
+ mControllers.navbarButtonsViewController.updateNavButtonTranslationY();
+ }
+ }
+
@Override
protected boolean isTaskbarTouchable() {
return !(mTaskbarLauncherStateController.isAnimatingToLauncher()
- && mTaskbarLauncherStateController.goingToAlignedLauncherState());
+ && mTaskbarLauncherStateController.isTaskbarAlignedWithHotseat());
}
public void setShouldDelayLauncherStateAnim(boolean shouldDelayLauncherStateAnim) {
@@ -169,15 +188,6 @@
@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
@@ -329,6 +339,11 @@
}
@Override
+ public void updateStateForSysuiFlags(int sysuiFlags, boolean skipAnim) {
+ mTaskbarLauncherStateController.updateStateForSysuiFlags(sysuiFlags, skipAnim);
+ }
+
+ @Override
public boolean isIconAlignedWithHotseat() {
return mTaskbarLauncherStateController.isIconAlignedWithHotseat();
}
@@ -364,9 +379,10 @@
public void dumpLogs(String prefix, PrintWriter pw) {
super.dumpLogs(prefix, pw);
- pw.println(String.format("%s\tTaskbar in-app display progress:", prefix));
+ pw.println(String.format("%s\tTaskbar in-app display progress: %.2f", prefix,
+ mTaskbarInAppDisplayProgress.value));
mTaskbarInAppDisplayProgressMultiProp.dump(
- prefix + "\t",
+ prefix + "\t\t",
pw,
"mTaskbarInAppDisplayProgressMultiProp",
"MINUS_ONE_PAGE_PROGRESS_INDEX",
diff --git a/quickstep/src/com/android/launcher3/taskbar/NavbarButtonsViewController.java b/quickstep/src/com/android/launcher3/taskbar/NavbarButtonsViewController.java
index fd19695..352740f 100644
--- a/quickstep/src/com/android/launcher3/taskbar/NavbarButtonsViewController.java
+++ b/quickstep/src/com/android/launcher3/taskbar/NavbarButtonsViewController.java
@@ -159,6 +159,7 @@
this::updateNavButtonTranslationY);
private final AnimatedFloat mTaskbarNavButtonTranslationYForIme = new AnimatedFloat(
this::updateNavButtonTranslationY);
+ private float mLastSetNavButtonTranslationY;
// Used for System UI state updates that should translate the nav button for in-app display.
private final AnimatedFloat mNavButtonInAppDisplayProgressForSysui = new AnimatedFloat(
this::updateNavButtonInAppDisplayProgressForSysui);
@@ -606,7 +607,10 @@
}
}
- private void updateNavButtonTranslationY() {
+ /**
+ * Sets the translationY of the nav buttons based on the current device state.
+ */
+ public void updateNavButtonTranslationY() {
if (isPhoneButtonNavMode(mContext)) {
return;
}
@@ -618,9 +622,10 @@
&& ((LauncherTaskbarUIController) uiController).shouldUseInAppLayout())
? mTaskbarNavButtonTranslationYForInAppDisplay.value : 0;
- mNavButtonsView.setTranslationY(normalTranslationY
+ mLastSetNavButtonTranslationY = normalTranslationY
+ imeAdjustmentTranslationY
- + inAppDisplayAdjustmentTranslationY);
+ + inAppDisplayAdjustmentTranslationY;
+ mNavButtonsView.setTranslationY(mLastSetNavButtonTranslationY);
}
private void updateNavButtonColor() {
@@ -924,6 +929,13 @@
pw.println(prefix + "\tmFloatingRotationButtonBounds=" + mFloatingRotationButtonBounds);
pw.println(prefix + "\tmSysuiStateFlags=" + QuickStepContract.getSystemUiStateString(
mSysuiStateFlags));
+ pw.println(prefix + "\tLast set nav button translationY=" + mLastSetNavButtonTranslationY);
+ pw.println(prefix + "\t\tmTaskbarNavButtonTranslationY="
+ + mTaskbarNavButtonTranslationY.value);
+ pw.println(prefix + "\t\tmTaskbarNavButtonTranslationYForInAppDisplay="
+ + mTaskbarNavButtonTranslationYForInAppDisplay.value);
+ pw.println(prefix + "\t\tmTaskbarNavButtonTranslationYForIme="
+ + mTaskbarNavButtonTranslationYForIme.value);
}
private static String getStateString(int flags) {
diff --git a/quickstep/src/com/android/launcher3/taskbar/StashedHandleViewController.java b/quickstep/src/com/android/launcher3/taskbar/StashedHandleViewController.java
index f082fc6..48b3f72 100644
--- a/quickstep/src/com/android/launcher3/taskbar/StashedHandleViewController.java
+++ b/quickstep/src/com/android/launcher3/taskbar/StashedHandleViewController.java
@@ -84,6 +84,9 @@
private boolean mIsStashed;
private boolean mTaskbarHidden;
+ private float mTranslationYForSwipe;
+ private float mTranslationYForStash;
+
public StashedHandleViewController(TaskbarActivityContext activity,
StashedHandleView stashedHandleView) {
mActivity = activity;
@@ -254,7 +257,20 @@
* Sets the translation of the stashed handle during the swipe up gesture.
*/
protected void setTranslationYForSwipe(float transY) {
- mStashedHandleView.setTranslationY(transY);
+ mTranslationYForSwipe = transY;
+ updateTranslationY();
+ }
+
+ /**
+ * Sets the translation of the stashed handle during the spring on stash animation.
+ */
+ protected void setTranslationYForStash(float transY) {
+ mTranslationYForStash = transY;
+ updateTranslationY();
+ }
+
+ private void updateTranslationY() {
+ mStashedHandleView.setTranslationY(mTranslationYForSwipe + mTranslationYForStash);
}
/**
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarActivityContext.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarActivityContext.java
index 62713ca..77a9d78 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarActivityContext.java
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarActivityContext.java
@@ -56,7 +56,6 @@
import android.view.RoundedCorner;
import android.view.View;
import android.view.WindowManager;
-import android.view.WindowManagerGlobal;
import android.widget.FrameLayout;
import android.widget.Toast;
@@ -80,6 +79,7 @@
import com.android.launcher3.model.data.FolderInfo;
import com.android.launcher3.model.data.ItemInfo;
import com.android.launcher3.model.data.WorkspaceItemInfo;
+import com.android.launcher3.popup.PopupContainerWithArrow;
import com.android.launcher3.popup.PopupDataProvider;
import com.android.launcher3.taskbar.TaskbarAutohideSuspendController.AutohideSuspendFlag;
import com.android.launcher3.taskbar.TaskbarTranslationController.TransitionCallback;
@@ -233,6 +233,7 @@
new TaskbarInsetsController(this),
new VoiceInteractionWindowController(this),
new TaskbarTranslationController(this),
+ new TaskbarSpringOnStashController(this),
isDesktopMode
? new DesktopTaskbarRecentAppsController(this)
: TaskbarRecentAppsController.DEFAULT,
@@ -524,6 +525,16 @@
setTaskbarWindowFocusable(isVisible);
}
+ @Override
+ public void onSplitScreenMenuButtonClicked() {
+ PopupContainerWithArrow popup = PopupContainerWithArrow.getOpen(this);
+ if (popup != null) {
+ popup.addOnCloseCallback(() -> {
+ mControllers.taskbarStashController.updateAndAnimateTransientTaskbar(true);
+ });
+ }
+ }
+
/**
* Sets a new data-source for this taskbar instance
*/
@@ -578,6 +589,8 @@
mControllers.taskbarForceVisibleImmersiveController.updateSysuiFlags(systemUiStateFlags);
mControllers.voiceInteractionWindowController.setIsVoiceInteractionWindowVisible(
(systemUiStateFlags & SYSUI_STATE_VOICE_INTERACTION_WINDOW_SHOWING) != 0, fromInit);
+
+ mControllers.uiController.updateStateForSysuiFlags(systemUiStateFlags, fromInit);
}
/**
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarBackgroundRenderer.kt b/quickstep/src/com/android/launcher3/taskbar/TaskbarBackgroundRenderer.kt
index 3375877..82b455d 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarBackgroundRenderer.kt
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarBackgroundRenderer.kt
@@ -35,6 +35,7 @@
val lastDrawnTransientRect = RectF()
var backgroundHeight = context.deviceProfile.taskbarSize.toFloat()
var translationYForSwipe = 0f
+ var translationYForStash = 0f
private var maxBackgroundHeight = context.deviceProfile.taskbarSize.toFloat()
private val transientBackgroundBounds = context.transientTaskbarBounds
@@ -136,7 +137,9 @@
val bottom =
canvas.height - bottomMargin +
bottomMarginProgress +
- (-mapRange(1f - progress, 0f, stashedHandleHeight / 2f) + translationYForSwipe)
+ translationYForSwipe +
+ translationYForStash +
+ -mapRange(1f - progress, 0f, stashedHandleHeight / 2f)
// Draw shadow.
val shadowAlpha =
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarControllers.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarControllers.java
index 931d79f..a6da56d 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarControllers.java
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarControllers.java
@@ -57,6 +57,7 @@
public final VoiceInteractionWindowController voiceInteractionWindowController;
public final TaskbarRecentAppsController taskbarRecentAppsController;
public final TaskbarTranslationController taskbarTranslationController;
+ public final TaskbarSpringOnStashController taskbarSpringOnStashController;
public final TaskbarOverlayController taskbarOverlayController;
public final TaskbarEduTooltipController taskbarEduTooltipController;
public final KeyboardQuickSwitchController keyboardQuickSwitchController;
@@ -103,6 +104,7 @@
TaskbarInsetsController taskbarInsetsController,
VoiceInteractionWindowController voiceInteractionWindowController,
TaskbarTranslationController taskbarTranslationController,
+ TaskbarSpringOnStashController taskbarSpringOnStashController,
TaskbarRecentAppsController taskbarRecentAppsController,
TaskbarEduTooltipController taskbarEduTooltipController,
KeyboardQuickSwitchController keyboardQuickSwitchController) {
@@ -127,6 +129,7 @@
this.taskbarInsetsController = taskbarInsetsController;
this.voiceInteractionWindowController = voiceInteractionWindowController;
this.taskbarTranslationController = taskbarTranslationController;
+ this.taskbarSpringOnStashController = taskbarSpringOnStashController;
this.taskbarRecentAppsController = taskbarRecentAppsController;
this.taskbarEduTooltipController = taskbarEduTooltipController;
this.keyboardQuickSwitchController = keyboardQuickSwitchController;
@@ -149,6 +152,7 @@
taskbarScrimViewController.init(this);
taskbarUnfoldAnimationController.init(this);
taskbarKeyguardController.init(navbarButtonsViewController);
+ taskbarSpringOnStashController.init(this);
stashedHandleViewController.init(this);
taskbarStashController.init(this, sharedState.setupUIVisible);
taskbarEduController.init(this);
@@ -209,7 +213,6 @@
uiController.onDestroy();
rotationButtonController.onDestroy();
taskbarDragLayerController.onDestroy();
- taskbarKeyguardController.onDestroy();
taskbarUnfoldAnimationController.onDestroy();
taskbarViewController.onDestroy();
stashedHandleViewController.onDestroy();
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarDragLayer.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarDragLayer.java
index 58d6244..6b9297d 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarDragLayer.java
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarDragLayer.java
@@ -184,6 +184,14 @@
invalidate();
}
+ /*
+ * Sets the translation of the background during the spring on stash animation.
+ */
+ protected void setBackgroundTranslationYForStash(float translationY) {
+ mBackgroundRenderer.setTranslationYForStash(translationY);
+ invalidate();
+ }
+
/** Returns the bounds in DragLayer coordinates of where the transient background was drawn. */
protected RectF getLastDrawnTransientRect() {
return mBackgroundRenderer.getLastDrawnTransientRect();
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarDragLayerController.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarDragLayerController.java
index 7c3d14d..2badc24 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarDragLayerController.java
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarDragLayerController.java
@@ -161,6 +161,13 @@
mTaskbarDragLayer.setBackgroundTranslationYForSwipe(transY);
}
+ /**
+ * Sets the translation of the background during the spring on stash animation.
+ */
+ public void setTranslationYForStash(float transY) {
+ mTaskbarDragLayer.setBackgroundTranslationYForStash(transY);
+ }
+
private void updateBackgroundOffset() {
mTaskbarDragLayer.setTaskbarBackgroundOffset(mBgOffset.value);
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarKeyguardController.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarKeyguardController.java
index 93ba4eb..8cc8965 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarKeyguardController.java
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarKeyguardController.java
@@ -1,19 +1,20 @@
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,41 @@
*/
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;
+ // If any of these SysUi flags (via QuickstepContract) is set, the device to be considered
+ // locked.
+ public static final int MASK_ANY_SYSUI_LOCKED = SYSUI_STATE_BOUNCER_SHOWING
+ | SYSUI_STATE_STATUS_BAR_KEYGUARD_SHOWING
+ | SYSUI_STATE_STATUS_BAR_KEYGUARD_SHOWING_OCCLUDED;
+
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 +66,6 @@
(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,19 +73,17 @@
keyguardOccluded);
updateIconsForBouncer();
- if (keyguardShowing) {
- AbstractFloatingView.closeOpenViews(mContext, true, TYPE_ALL);
+ boolean screenOffOrTransitioningOff = (systemUiStateFlags & SYSUI_STATE_SCREEN_ON) == 0;
+ boolean closeFloatingViews = keyguardShowing || screenOffOrTransitioningOff;
+
+ 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 boolean isScreenOff() {
- return mIsScreenOff;
- }
-
- public void setScreenOn() {
- mIsScreenOff = false;
- }
-
/**
* Hides/shows taskbar when keyguard is up
*/
@@ -95,9 +94,6 @@
mNavbarButtonsViewController.setBackForBouncer(showBackForBouncer);
}
- public void onDestroy() {
- ScreenOnTracker.INSTANCE.get(mContext).removeListener(mScreenOnListener);
- }
@Override
public void dumpLogs(String prefix, PrintWriter pw) {
@@ -106,6 +102,5 @@
pw.println(prefix + "\tmKeyguardSysuiFlags=" + QuickStepContract.getSystemUiStateString(
mKeyguardSysuiFlags));
pw.println(prefix + "\tmBouncerShowing=" + mBouncerShowing);
- pw.println(prefix + "\tmIsScreenOff=" + mIsScreenOff);
}
}
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarLauncherStateController.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarLauncherStateController.java
index 7d5a400..a6c38da 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarLauncherStateController.java
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarLauncherStateController.java
@@ -15,10 +15,14 @@
*/
package com.android.launcher3.taskbar;
+import static com.android.launcher3.taskbar.TaskbarKeyguardController.MASK_ANY_SYSUI_LOCKED;
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;
@@ -53,16 +57,46 @@
* Track LauncherState, RecentsAnimation, resumed state for task bar in one place here and animate
* the task bar accordingly.
*/
- public class TaskbarLauncherStateController {
+public class TaskbarLauncherStateController {
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;
+
+ /** Whether the device is currently locked. */
+ private static final int FLAG_DEVICE_LOCKED = 1 << 5;
+
+ 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 +149,13 @@
@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 +168,7 @@
@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 +194,6 @@
resetIconAlignment();
mLauncher.getStateManager().addStateListener(mStateListener);
-
- // Initialize to the current launcher state
- updateStateForFlag(FLAG_RESUMED, launcher.hasBeenResumed());
mLauncherState = launcher.getStateManager().getState();
applyState(0);
@@ -182,6 +214,12 @@
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 +235,7 @@
}
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,12 +263,35 @@
mShouldDelayLauncherStateAnim = shouldDelayLauncherStateAnim;
}
+ /** SysUI flags updated, see QuickStepContract.SYSUI_STATE_* values. */
+ public void updateStateForSysuiFlags(int systemUiStateFlags, boolean skipAnim) {
+ final boolean prevScreenIsOn = hasAnyFlag(FLAG_SCREEN_ON);
+ final boolean currScreenIsOn = hasAnyFlag(systemUiStateFlags, SYSUI_STATE_SCREEN_ON);
+
+ updateStateForFlag(FLAG_SCREEN_ON, currScreenIsOn);
+ if (prevScreenIsOn != currScreenIsOn) {
+ // The screen is switching between on/off. When turning off, capture whether the
+ // launcher is active and memoize this state.
+ updateStateForFlag(FLAG_LAUNCHER_ACTIVE_AT_SCREEN_OFF,
+ prevScreenIsOn && hasAnyFlag(FLAGS_LAUNCHER_ACTIVE));
+ }
+
+ boolean isDeviceLocked = hasAnyFlag(systemUiStateFlags, MASK_ANY_SYSUI_LOCKED);
+ updateStateForFlag(FLAG_DEVICE_LOCKED, isDeviceLocked);
+
+ if (skipAnim) {
+ applyState(0);
+ } else {
+ applyState();
+ }
+ }
+
/**
* Updates the proper flag to change the state of the task bar.
*
* Note that this only updates the flag. {@link #applyState()} needs to be called separately.
*
- * @param flag The flag to update.
+ * @param flag The flag to update.
* @param enabled Whether to enable the flag
*/
public void updateStateForFlag(int flag, boolean enabled) {
@@ -269,6 +330,19 @@
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 +350,23 @@
}
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 +377,37 @@
}
}
- 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 +418,20 @@
+ " -> " + 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 +443,8 @@
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) {
@@ -386,7 +457,13 @@
animatorSet.play(mTaskbarCornerRoundness.animateToValue(cornerRoundness));
}
- if (mIconAlignment.isAnimatingToValue(toAlignment)
+ if (hasAnyFlag(changedFlags, FLAG_DEVICE_LOCKED)) {
+ // When transitioning between locked/unlocked, there is no stashing animation.
+ mIconAlignment.cancelAnimation();
+ // updateValue ensures onIconAlignmentRatioChanged will be called if there is an actual
+ // change in value
+ mIconAlignment.updateValue(toAlignment);
+ } else if (mIconAlignment.isAnimatingToValue(toAlignment)
|| mIconAlignment.isSettledOnValue(toAlignment)) {
// Already at desired value, but make sure we run the callback at the end.
animatorSet.addListener(AnimatorListeners.forEndCallback(
@@ -412,8 +489,12 @@
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 +562,13 @@
}
}
+ /** 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 +595,8 @@
if (firstFrameVisChanged && mCanSyncViews && !Utilities.isRunningInTestHarness()) {
ViewRootSync.synchronizeNextDraw(mLauncher.getHotseat(),
mControllers.taskbarActivityContext.getDragLayer(),
- () -> {});
+ () -> {
+ });
}
}
@@ -562,7 +649,7 @@
// 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 +663,16 @@
}
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");
+ appendFlag(result, flags, FLAG_DEVICE_LOCKED, "device_locked");
+ return result.toString();
}
protected void dumpLogs(String prefix, PrintWriter pw) {
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarPopupController.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarPopupController.java
index 115b99e..0ed4538 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarPopupController.java
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarPopupController.java
@@ -65,6 +65,7 @@
/**
* Implements interfaces required to show and allow interacting with a PopupContainerWithArrow.
+ * Controls the long-press menu on Taskbar and AllApps icons.
*/
public class TaskbarPopupController implements TaskbarControllers.LoggableTaskbarController {
@@ -174,6 +175,7 @@
deepShortcutCount,
mPopupDataProvider.getNotificationKeysForItem(item),
systemShortcuts);
+ icon.clearAccessibilityFocus();
}
container.addOnAttachStateChangeListener(
@@ -190,9 +192,8 @@
// Make focusable to receive back events
context.onPopupVisibilityChanged(true);
- container.setOnCloseCallback(() -> {
+ container.addOnCloseCallback(() -> {
context.getDragLayer().post(() -> context.onPopupVisibilityChanged(false));
- container.setOnCloseCallback(null);
});
return container;
@@ -293,13 +294,19 @@
@Override
public void onClick(View view) {
+ // Add callbacks depending on what type of Taskbar context we're in (Taskbar or AllApps)
+ mTarget.onSplitScreenMenuButtonClicked();
AbstractFloatingView.closeAllOpenViews(mTarget);
+
+ // Depending on what app state we're in, we either want to initiate the split screen
+ // staging process or immediately launch a split with an existing app.
+ // - Initiate the split screen staging process
if (mAllowInitialSplitSelection) {
super.onClick(view);
return;
}
- // Initiate splitscreen from the in-app Taskbar or Taskbar All Apps
+ // - Immediately launch split with the running app
Pair<InstanceId, com.android.launcher3.logging.InstanceId> instanceIds =
LogUtils.getShellShareableInstanceId();
mTarget.getStatsLogManager().logger()
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarSharedState.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarSharedState.java
index 026eff7..6092998 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarSharedState.java
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarSharedState.java
@@ -15,6 +15,8 @@
*/
package com.android.launcher3.taskbar;
+import static com.android.launcher3.taskbar.LauncherTaskbarUIController.DISPLAY_PROGRESS_COUNT;
+
/**
* State shared across different taskbar instance
*/
@@ -38,4 +40,7 @@
public boolean setupUIVisible = false;
public boolean allAppsVisible = false;
+
+ // LauncherTaskbarUIController#mTaskbarInAppDisplayProgressMultiProp
+ public float[] inAppDisplayProgressMultiPropValues = new float[DISPLAY_PROGRESS_COUNT];
}
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarSpringOnStashController.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarSpringOnStashController.java
new file mode 100644
index 0000000..d65b5c0
--- /dev/null
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarSpringOnStashController.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.launcher3.taskbar;
+
+import static com.android.launcher3.anim.AnimatedFloat.VALUE;
+
+import android.animation.ValueAnimator;
+
+import androidx.annotation.Nullable;
+import androidx.dynamicanimation.animation.SpringForce;
+
+import com.android.launcher3.R;
+import com.android.launcher3.anim.AnimatedFloat;
+import com.android.launcher3.anim.SpringAnimationBuilder;
+import com.android.launcher3.taskbar.TaskbarControllers.LoggableTaskbarController;
+import com.android.launcher3.util.DisplayController;
+
+import java.io.PrintWriter;
+
+/**
+ * Manages the spring animation when stashing the transient taskbar.
+ */
+public class TaskbarSpringOnStashController implements LoggableTaskbarController {
+
+ private final TaskbarActivityContext mContext;
+ private TaskbarControllers mControllers;
+ private final AnimatedFloat mTranslationForStash = new AnimatedFloat(
+ this::updateTranslationYForStash);
+
+ private final boolean mIsTransientTaskbar;
+
+ private final float mStartVelocityPxPerS;
+
+ public TaskbarSpringOnStashController(TaskbarActivityContext context) {
+ mContext = context;
+ mIsTransientTaskbar = DisplayController.isTransientTaskbar(mContext);
+ mStartVelocityPxPerS = context.getResources()
+ .getDimension(R.dimen.transient_taskbar_stash_spring_velocity_dp_per_s);
+ }
+
+ /**
+ * Initialization method.
+ */
+ public void init(TaskbarControllers controllers) {
+ mControllers = controllers;
+ }
+
+ private void updateTranslationYForStash() {
+ if (!mIsTransientTaskbar) {
+ return;
+ }
+
+ float transY = mTranslationForStash.value;
+ mControllers.stashedHandleViewController.setTranslationYForStash(transY);
+ mControllers.taskbarViewController.setTranslationYForStash(transY);
+ mControllers.taskbarDragLayerController.setTranslationYForStash(transY);
+ }
+
+ /**
+ * Returns a spring animation to be used when stashing the transient taskbar.
+ */
+ public @Nullable ValueAnimator createSpringToStash() {
+ if (!mIsTransientTaskbar) {
+ return null;
+ }
+ return new SpringAnimationBuilder(mContext)
+ .setStartValue(mTranslationForStash.value)
+ .setEndValue(0)
+ .setDampingRatio(SpringForce.DAMPING_RATIO_MEDIUM_BOUNCY)
+ .setStiffness(SpringForce.STIFFNESS_LOW)
+ .setStartVelocity(mStartVelocityPxPerS)
+ .build(mTranslationForStash, VALUE);
+ }
+
+
+ @Override
+ public void dumpLogs(String prefix, PrintWriter pw) {
+ pw.println(prefix + "TaskbarSpringOnStashController:");
+
+ pw.println(prefix + "\tmTranslationForStash=" + mTranslationForStash.value);
+ pw.println(prefix + "\tmStartVelocityPxPerS=" + mStartVelocityPxPerS);
+ }
+}
+
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarStashController.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarStashController.java
index cbc1672..d26fbc4 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarStashController.java
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarStashController.java
@@ -27,16 +27,14 @@
import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_TASKBAR_LONGPRESS_SHOW;
import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_TRANSIENT_TASKBAR_HIDE;
import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_TRANSIENT_TASKBAR_SHOW;
+import static com.android.launcher3.taskbar.TaskbarKeyguardController.MASK_ANY_SYSUI_LOCKED;
import static com.android.launcher3.util.FlagDebugUtils.appendFlag;
import static com.android.launcher3.util.FlagDebugUtils.formatFlagChange;
-import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_BOUNCER_SHOWING;
import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_IME_SHOWING;
import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_IME_SWITCHER_SHOWING;
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_PINNING;
-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.animation.Animator;
import android.animation.AnimatorListenerAdapter;
@@ -81,7 +79,7 @@
public static final int FLAG_IN_APP = 1 << 0;
public static final int FLAG_STASHED_IN_APP_MANUAL = 1 << 1; // long press, persisted
- public static final int FLAG_STASHED_IN_SYSUI_STATE = 1 << 2; // app pinning, keyguard, etc.
+ public static final int FLAG_STASHED_IN_APP_SYSUI = 1 << 2; // shade open, ...
public static final int FLAG_STASHED_IN_APP_SETUP = 1 << 3; // setup wizard and AllSetActivity
public static final int FLAG_STASHED_IN_APP_IME = 1 << 4; // IME is visible
public static final int FLAG_IN_STASHED_LAUNCHER_STATE = 1 << 5;
@@ -89,13 +87,15 @@
public static final int FLAG_IN_SETUP = 1 << 7; // In the Setup Wizard
public static final int FLAG_STASHED_SMALL_SCREEN = 1 << 8; // phone screen gesture nav, stashed
public static final int FLAG_STASHED_IN_APP_AUTO = 1 << 9; // Autohide (transient taskbar).
+ public static final int FLAG_STASHED_SYSUI = 1 << 10; // app pinning,...
+ public static final int FLAG_STASHED_DEVICE_LOCKED = 1 << 11; // device is locked: keyguard, ...
// If any of these flags are enabled, isInApp should return true.
private static final int FLAGS_IN_APP = FLAG_IN_APP | FLAG_IN_SETUP;
// If we're in an app and any of these flags are enabled, taskbar should be stashed.
private static final int FLAGS_STASHED_IN_APP = FLAG_STASHED_IN_APP_MANUAL
- | FLAG_STASHED_IN_SYSUI_STATE | FLAG_STASHED_IN_APP_SETUP
+ | FLAG_STASHED_IN_APP_SYSUI | FLAG_STASHED_IN_APP_SETUP
| FLAG_STASHED_IN_APP_IME | FLAG_STASHED_IN_TASKBAR_ALL_APPS
| FLAG_STASHED_SMALL_SCREEN | FLAG_STASHED_IN_APP_AUTO;
@@ -109,6 +109,10 @@
private static final int FLAGS_REPORT_STASHED_INSETS_TO_APP = FLAGS_STASHED_IN_APP
& ~FLAG_STASHED_IN_APP_IME & ~FLAG_STASHED_IN_TASKBAR_ALL_APPS;
+ // If any of these flags are enabled, the taskbar must be stashed.
+ private static final int FLAGS_FORCE_STASHED = FLAG_STASHED_SYSUI | FLAG_STASHED_DEVICE_LOCKED
+ | FLAG_STASHED_IN_TASKBAR_ALL_APPS | FLAG_STASHED_SMALL_SCREEN;
+
/**
* How long to stash/unstash when manually invoked via long press.
*
@@ -218,11 +222,8 @@
boolean inApp = hasAnyFlag(flags, FLAGS_IN_APP);
boolean stashedInApp = hasAnyFlag(flags, FLAGS_STASHED_IN_APP);
boolean stashedLauncherState = hasAnyFlag(flags, FLAG_IN_STASHED_LAUNCHER_STATE);
- boolean stashedInTaskbarAllApps =
- hasAnyFlag(flags, FLAG_STASHED_IN_TASKBAR_ALL_APPS);
- boolean stashedForSmallScreen = hasAnyFlag(flags, FLAG_STASHED_SMALL_SCREEN);
- return (inApp && stashedInApp) || (!inApp && stashedLauncherState)
- || stashedInTaskbarAllApps || stashedForSmallScreen;
+ boolean forceStashed = hasAnyFlag(flags, FLAGS_FORCE_STASHED);
+ return (inApp && stashedInApp) || (!inApp && stashedLauncherState) || forceStashed;
});
public TaskbarStashController(TaskbarActivityContext activity) {
@@ -583,8 +584,12 @@
// If Hotseat is not the top element during animation to/from Launcher, fade in/out a
// already stashed Taskbar.
- boolean skipStashAnimation = !mControllers.uiController.isHotseatIconOnTopWhenAligned()
- && hasAnyFlag(changedFlags, FLAG_IN_APP);
+ boolean hotseatTopElement = mControllers.uiController.isHotseatIconOnTopWhenAligned()
+ || !hasAnyFlag(changedFlags, FLAG_IN_APP);
+ // If transitioning between locked/unlocked device, do not play a stash animation.
+ boolean unLockedTransition = hasAnyFlag(changedFlags, FLAG_STASHED_DEVICE_LOCKED);
+ boolean skipStashAnimation = !hotseatTopElement || unLockedTransition;
+
if (isTransientTaskbar) {
createTransientAnimToIsStashed(mAnimator, isStashed, duration, animateBg, changedFlags,
skipStashAnimation);
@@ -712,6 +717,9 @@
play(as, mTaskbarStashedHandleAlpha.animateToValue(1), alphaStartDelay,
Math.max(0, duration - alphaStartDelay), LINEAR);
+ play(as, mControllers.taskbarSpringOnStashController.createSpringToStash(), 0, duration,
+ LINEAR);
+
if (skipStashAnimation) {
skipInterpolator = INSTANT;
}
@@ -898,13 +906,13 @@
long animDuration = TASKBAR_STASH_DURATION;
long startDelay = 0;
- updateStateForFlag(FLAG_STASHED_IN_SYSUI_STATE, hasAnyFlag(systemUiStateFlags,
- SYSUI_STATE_SCREEN_PINNING
- | SYSUI_STATE_BOUNCER_SHOWING
- | SYSUI_STATE_STATUS_BAR_KEYGUARD_SHOWING
- | SYSUI_STATE_STATUS_BAR_KEYGUARD_SHOWING_OCCLUDED
- | SYSUI_STATE_NOTIFICATION_PANEL_EXPANDED
- | SYSUI_STATE_QUICK_SETTINGS_EXPANDED));
+ updateStateForFlag(FLAG_STASHED_IN_APP_SYSUI, hasAnyFlag(systemUiStateFlags,
+ SYSUI_STATE_QUICK_SETTINGS_EXPANDED
+ | SYSUI_STATE_NOTIFICATION_PANEL_EXPANDED));
+ updateStateForFlag(FLAG_STASHED_SYSUI,
+ hasAnyFlag(systemUiStateFlags, SYSUI_STATE_SCREEN_PINNING));
+ updateStateForFlag(FLAG_STASHED_DEVICE_LOCKED,
+ hasAnyFlag(systemUiStateFlags, MASK_ANY_SYSUI_LOCKED));
// Only update FLAG_STASHED_IN_APP_IME when system gesture is not in progress.
mIsImeShowing = hasAnyFlag(systemUiStateFlags, SYSUI_STATE_IME_SHOWING);
@@ -1068,13 +1076,15 @@
StringJoiner sj = new StringJoiner("|");
appendFlag(sj, flags, FLAGS_IN_APP, "FLAG_IN_APP");
appendFlag(sj, flags, FLAG_STASHED_IN_APP_MANUAL, "FLAG_STASHED_IN_APP_MANUAL");
- appendFlag(sj, flags, FLAG_STASHED_IN_SYSUI_STATE, "FLAG_STASHED_IN_SYSUI_STATE");
+ appendFlag(sj, flags, FLAG_STASHED_IN_APP_SYSUI, "FLAG_STASHED_IN_APP_SYSUI");
appendFlag(sj, flags, FLAG_STASHED_IN_APP_SETUP, "FLAG_STASHED_IN_APP_SETUP");
appendFlag(sj, flags, FLAG_STASHED_IN_APP_IME, "FLAG_STASHED_IN_APP_IME");
appendFlag(sj, flags, FLAG_IN_STASHED_LAUNCHER_STATE, "FLAG_IN_STASHED_LAUNCHER_STATE");
appendFlag(sj, flags, FLAG_STASHED_IN_TASKBAR_ALL_APPS, "FLAG_STASHED_IN_TASKBAR_ALL_APPS");
appendFlag(sj, flags, FLAG_IN_SETUP, "FLAG_IN_SETUP");
appendFlag(sj, flags, FLAG_STASHED_IN_APP_AUTO, "FLAG_STASHED_IN_APP_AUTO");
+ appendFlag(sj, flags, FLAG_STASHED_SYSUI, "FLAG_STASHED_SYSUI");
+ appendFlag(sj, flags, FLAG_STASHED_DEVICE_LOCKED, "FLAG_STASHED_DEVICE_LOCKED");
return sj.toString();
}
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarTranslationController.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarTranslationController.java
index 062b4ce..b9b63db 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarTranslationController.java
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarTranslationController.java
@@ -76,12 +76,11 @@
/**
* Called to cancel any existing animations.
*/
- public void cancelAnimationIfExists() {
+ public void cancelSpringIfExists() {
if (mSpringBounce != null) {
mSpringBounce.cancel();
mSpringBounce = null;
}
- reset();
}
private void updateTranslationYForSwipe() {
@@ -138,13 +137,14 @@
* Returns an animation to reset the taskbar translation to {@code 0}.
*/
public ObjectAnimator createAnimToResetTranslation(long duration) {
- ObjectAnimator animator = ObjectAnimator.ofFloat(mTranslationYForSwipe, VALUE, 0);
+ ObjectAnimator animator = mTranslationYForSwipe.animateToValue(0);
animator.setInterpolator(Interpolators.LINEAR);
animator.setDuration(duration);
animator.addListener(new AnimatorListenerAdapter() {
@Override
public void onAnimationStart(Animator animation) {
- cancelAnimationIfExists();
+ cancelSpringIfExists();
+ reset();
mAnimationToHomeRunning = true;
}
@@ -163,6 +163,18 @@
public class TransitionCallback {
/**
+ * Clears any existing animations so that user
+ * can take control over the movement of the taskbaer.
+ */
+ public void onActionDown() {
+ if (mAnimationToHomeRunning) {
+ mTranslationYForSwipe.cancelAnimation();
+ }
+ mAnimationToHomeRunning = false;
+ cancelSpringIfExists();
+ reset();
+ }
+ /**
* Called when there is movement to move the taskbar.
*/
public void onActionMove(float dY) {
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarUIController.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarUIController.java
index 4c6d3fa..b9242b2 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarUIController.java
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarUIController.java
@@ -125,6 +125,12 @@
}
/**
+ * SysUI flags updated, see QuickStepContract.SYSUI_STATE_* values.
+ */
+ public void updateStateForSysuiFlags(int sysuiFlags, boolean skipAnim){
+ }
+
+ /**
* Returns {@code true} iff taskbar is stashed.
*/
public boolean isTaskbarStashed() {
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarView.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarView.java
index 0116e16..c5b6cdf 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarView.java
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarView.java
@@ -47,6 +47,7 @@
import com.android.launcher3.model.data.WorkspaceItemInfo;
import com.android.launcher3.util.DisplayController;
import com.android.launcher3.util.LauncherBindableItemsContainer;
+import com.android.launcher3.util.Themes;
import com.android.launcher3.views.ActivityContext;
import com.android.launcher3.views.DoubleShadowBubbleTextView;
import com.android.launcher3.views.IconButtonView;
@@ -66,6 +67,7 @@
private final int mIconTouchSize;
private final int mItemMarginLeftRight;
private final int mItemPadding;
+ private final int mFolderLeaveBehindColor;
private final boolean mIsRtl;
private final TaskbarActivityContext mActivityContext;
@@ -132,6 +134,9 @@
mItemMarginLeftRight = actualMargin - (mIconTouchSize - actualIconSize) / 2;
mItemPadding = (mIconTouchSize - actualIconSize) / 2;
+ mFolderLeaveBehindColor = Themes.getAttrColor(mActivityContext,
+ android.R.attr.textColorTertiary);
+
// Needed to draw folder leave-behind when opening one.
setWillNotDraw(false);
@@ -523,7 +528,8 @@
if (mLeaveBehindFolderIcon != null) {
canvas.save();
canvas.translate(mLeaveBehindFolderIcon.getLeft(), mLeaveBehindFolderIcon.getTop());
- mLeaveBehindFolderIcon.getFolderBackground().drawLeaveBehind(canvas);
+ mLeaveBehindFolderIcon.getFolderBackground().drawLeaveBehind(canvas,
+ mFolderLeaveBehindColor);
canvas.restore();
}
}
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarViewController.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarViewController.java
index d03255b..fafd0bd 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarViewController.java
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarViewController.java
@@ -103,6 +103,7 @@
private AnimatedFloat mTaskbarNavButtonTranslationY;
private AnimatedFloat mTaskbarNavButtonTranslationYForInAppDisplay;
private float mTaskbarIconTranslationYForSwipe;
+ private float mTaskbarIconTranslationYForSpringOnStash;
private final int mTaskbarBottomMargin;
private final int mStashedHandleHeight;
@@ -291,10 +292,19 @@
updateTranslationY();
}
+ /**
+ * Sets the translation of the TaskbarView during the spring on stash animation.
+ */
+ public void setTranslationYForStash(float transY) {
+ mTaskbarIconTranslationYForSpringOnStash = transY;
+ updateTranslationY();
+ }
+
private void updateTranslationY() {
mTaskbarView.setTranslationY(mTaskbarIconTranslationYForHome.value
+ mTaskbarIconTranslationYForStash.value
- + mTaskbarIconTranslationYForSwipe);
+ + mTaskbarIconTranslationYForSwipe
+ + mTaskbarIconTranslationYForSpringOnStash);
}
/**
diff --git a/quickstep/src/com/android/launcher3/taskbar/overlay/TaskbarOverlayContext.java b/quickstep/src/com/android/launcher3/taskbar/overlay/TaskbarOverlayContext.java
index 3edb375..66d5918 100644
--- a/quickstep/src/com/android/launcher3/taskbar/overlay/TaskbarOverlayContext.java
+++ b/quickstep/src/com/android/launcher3/taskbar/overlay/TaskbarOverlayContext.java
@@ -15,8 +15,6 @@
*/
package com.android.launcher3.taskbar.overlay;
-import static android.app.ActivityTaskManager.INVALID_TASK_ID;
-
import android.content.Context;
import android.view.View;
@@ -33,10 +31,6 @@
import com.android.launcher3.taskbar.TaskbarUIController;
import com.android.launcher3.taskbar.allapps.TaskbarAllAppsContainerView;
import com.android.launcher3.util.SplitConfigurationOptions.SplitSelectSource;
-import com.android.quickstep.views.RecentsView;
-import com.android.systemui.shared.recents.model.Task;
-
-import java.util.function.Consumer;
/**
* Window context for the taskbar overlays such as All Apps and EDU.
@@ -141,4 +135,8 @@
@Override
public void onPopupVisibilityChanged(boolean isVisible) {}
+
+ @Override
+ public void onSplitScreenMenuButtonClicked() {
+ }
}
diff --git a/quickstep/src/com/android/quickstep/inputconsumers/TaskbarStashInputConsumer.java b/quickstep/src/com/android/quickstep/inputconsumers/TaskbarStashInputConsumer.java
index 1ddb855..a01d634 100644
--- a/quickstep/src/com/android/quickstep/inputconsumers/TaskbarStashInputConsumer.java
+++ b/quickstep/src/com/android/quickstep/inputconsumers/TaskbarStashInputConsumer.java
@@ -126,6 +126,10 @@
mCanceledUnstashHint = false;
}
}
+
+ if (mTransitionCallback != null && !mIsTaskbarAllAppsOpen) {
+ mTransitionCallback.onActionDown();
+ }
break;
case MotionEvent.ACTION_POINTER_UP:
int ptrIdx = ev.getActionIndex();
diff --git a/quickstep/tests/src/com/android/launcher3/taskbar/TaskbarBaseTestCase.kt b/quickstep/tests/src/com/android/launcher3/taskbar/TaskbarBaseTestCase.kt
index 4cca24e..172cb46 100644
--- a/quickstep/tests/src/com/android/launcher3/taskbar/TaskbarBaseTestCase.kt
+++ b/quickstep/tests/src/com/android/launcher3/taskbar/TaskbarBaseTestCase.kt
@@ -50,6 +50,7 @@
@Mock lateinit var voiceInteractionWindowController: VoiceInteractionWindowController
@Mock lateinit var taskbarRecentAppsController: TaskbarRecentAppsController
@Mock lateinit var taskbarTranslationController: TaskbarTranslationController
+ @Mock lateinit var taskbarSpringOnStashController: TaskbarSpringOnStashController
@Mock lateinit var taskbarOverlayController: TaskbarOverlayController
@Mock lateinit var taskbarEduTooltipController: TaskbarEduTooltipController
@Mock lateinit var keyboardQuickSwitchController: KeyboardQuickSwitchController
@@ -89,6 +90,7 @@
taskbarInsetsController,
voiceInteractionWindowController,
taskbarTranslationController,
+ taskbarSpringOnStashController,
taskbarRecentAppsController,
taskbarEduTooltipController,
keyboardQuickSwitchController
diff --git a/src/com/android/launcher3/CellLayout.java b/src/com/android/launcher3/CellLayout.java
index 38b0e08..37194b1 100644
--- a/src/com/android/launcher3/CellLayout.java
+++ b/src/com/android/launcher3/CellLayout.java
@@ -92,6 +92,9 @@
private static final String TAG = "CellLayout";
private static final boolean LOGD = false;
+ /** The color of the "leave-behind" shape when a folder is opened from Hotseat. */
+ private static final int FOLDER_LEAVE_BEHIND_COLOR = Color.argb(160, 245, 245, 245);
+
protected final ActivityContext mActivity;
@ViewDebug.ExportedProperty(category = "launcher")
@Thunk int mCellWidth;
@@ -528,7 +531,7 @@
mFolderLeaveBehind.mDelegateCellY, mTempLocation);
canvas.save();
canvas.translate(mTempLocation[0], mTempLocation[1]);
- mFolderLeaveBehind.drawLeaveBehind(canvas);
+ mFolderLeaveBehind.drawLeaveBehind(canvas, FOLDER_LEAVE_BEHIND_COLOR);
canvas.restore();
}
diff --git a/src/com/android/launcher3/LauncherAppState.java b/src/com/android/launcher3/LauncherAppState.java
index c81ad01..abf5866 100644
--- a/src/com/android/launcher3/LauncherAppState.java
+++ b/src/com/android/launcher3/LauncherAppState.java
@@ -31,7 +31,11 @@
import android.content.pm.LauncherApps;
import android.os.UserHandle;
import android.util.Log;
+import android.util.SparseArray;
+import android.widget.RemoteViews;
+import androidx.annotation.GuardedBy;
+import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import com.android.launcher3.config.FeatureFlags;
@@ -70,6 +74,12 @@
private final InvariantDeviceProfile mInvariantDeviceProfile;
private final RunnableList mOnTerminateCallback = new RunnableList();
+ // WORKAROUND: b/269335387 remove this after widget background listener is enabled
+ /* Array of RemoteViews cached by Launcher process */
+ @GuardedBy("itself")
+ @NonNull
+ public final SparseArray<RemoteViews> mCachedRemoteViews = new SparseArray<>();
+
public static LauncherAppState getInstance(final Context context) {
return INSTANCE.get(context);
}
diff --git a/src/com/android/launcher3/accessibility/LauncherAccessibilityDelegate.java b/src/com/android/launcher3/accessibility/LauncherAccessibilityDelegate.java
index 3c316b8..27119ae 100644
--- a/src/com/android/launcher3/accessibility/LauncherAccessibilityDelegate.java
+++ b/src/com/android/launcher3/accessibility/LauncherAccessibilityDelegate.java
@@ -174,7 +174,7 @@
mContext.getDragLayer().getDescendantRectRelativeToSelf(host, pos);
ArrowPopup popup = OptionsPopupView.show(mContext, new RectF(pos), actions, false);
popup.requestFocus();
- popup.setOnCloseCallback(() -> {
+ popup.addOnCloseCallback(() -> {
host.requestFocus();
host.sendAccessibilityEvent(TYPE_VIEW_FOCUSED);
host.performAccessibilityAction(ACTION_ACCESSIBILITY_FOCUS, null);
diff --git a/src/com/android/launcher3/folder/PreviewBackground.java b/src/com/android/launcher3/folder/PreviewBackground.java
index 8f9fa8a..2465745 100644
--- a/src/com/android/launcher3/folder/PreviewBackground.java
+++ b/src/com/android/launcher3/folder/PreviewBackground.java
@@ -333,12 +333,15 @@
getOffsetX() + inset, getOffsetY() + inset, getScaledRadius() - inset, mPaint);
}
- public void drawLeaveBehind(Canvas canvas) {
+ /**
+ * Draws the leave-behind circle on the given canvas and in the given color.
+ */
+ public void drawLeaveBehind(Canvas canvas, int color) {
float originalScale = mScale;
mScale = 0.5f;
mPaint.setStyle(Paint.Style.FILL);
- mPaint.setColor(Color.argb(160, 245, 245, 245));
+ mPaint.setColor(color);
getShape().drawShape(canvas, getOffsetX(), getOffsetY(), getScaledRadius(), mPaint);
mScale = originalScale;
diff --git a/src/com/android/launcher3/popup/ArrowPopup.java b/src/com/android/launcher3/popup/ArrowPopup.java
index be3a09b..9d06d4a 100644
--- a/src/com/android/launcher3/popup/ArrowPopup.java
+++ b/src/com/android/launcher3/popup/ArrowPopup.java
@@ -48,14 +48,13 @@
import android.view.animation.PathInterpolator;
import android.widget.FrameLayout;
-import androidx.annotation.Nullable;
-
import com.android.launcher3.AbstractFloatingView;
import com.android.launcher3.InsettableFrameLayout;
import com.android.launcher3.R;
import com.android.launcher3.Utilities;
import com.android.launcher3.dragndrop.DragLayer;
import com.android.launcher3.shortcuts.DeepShortcutView;
+import com.android.launcher3.util.RunnableList;
import com.android.launcher3.util.Themes;
import com.android.launcher3.views.ActivityContext;
import com.android.launcher3.views.BaseDragLayer;
@@ -124,7 +123,7 @@
private final GradientDrawable mRoundedTop;
private final GradientDrawable mRoundedBottom;
- @Nullable private Runnable mOnCloseCallback = null;
+ private RunnableList mOnCloseCallbacks = new RunnableList();
// The rect string of the view that the arrow is attached to, in screen reference frame.
protected int mArrowColor;
@@ -785,16 +784,14 @@
mDeferContainerRemoval = false;
getPopupContainer().removeView(this);
getPopupContainer().removeView(mArrow);
- if (mOnCloseCallback != null) {
- mOnCloseCallback.run();
- }
+ mOnCloseCallbacks.executeAllAndClear();
}
/**
- * Callback to be called when the popup is closed
+ * Callbacks to be called when the popup is closed
*/
- public void setOnCloseCallback(@Nullable Runnable callback) {
- mOnCloseCallback = callback;
+ public void addOnCloseCallback(Runnable callback) {
+ mOnCloseCallbacks.add(callback);
}
protected BaseDragLayer getPopupContainer() {
diff --git a/src/com/android/launcher3/widget/LauncherWidgetHolder.java b/src/com/android/launcher3/widget/LauncherWidgetHolder.java
index 8e67eb1..2ca825c 100644
--- a/src/com/android/launcher3/widget/LauncherWidgetHolder.java
+++ b/src/com/android/launcher3/widget/LauncherWidgetHolder.java
@@ -36,6 +36,7 @@
import com.android.launcher3.BaseActivity;
import com.android.launcher3.BaseDraggingActivity;
+import com.android.launcher3.LauncherAppState;
import com.android.launcher3.R;
import com.android.launcher3.Utilities;
import com.android.launcher3.config.FeatureFlags;
@@ -74,8 +75,6 @@
private final SparseArray<PendingAppWidgetHostView> mPendingViews = new SparseArray<>();
@NonNull
private final SparseArray<LauncherAppWidgetHostView> mDeferredViews = new SparseArray<>();
- @NonNull
- private final SparseArray<RemoteViews> mCachedRemoteViews = new SparseArray<>();
protected int mFlags = FLAG_STATE_IS_NORMAL;
@@ -174,6 +173,12 @@
public void deleteAppWidgetId(int appWidgetId) {
mWidgetHost.deleteAppWidgetId(appWidgetId);
mViews.remove(appWidgetId);
+ if (FeatureFlags.ENABLE_CACHED_WIDGET.get()) {
+ final LauncherAppState state = LauncherAppState.getInstance(mContext);
+ synchronized (state.mCachedRemoteViews) {
+ state.mCachedRemoteViews.delete(appWidgetId);
+ }
+ }
}
/**
@@ -308,7 +313,17 @@
if (WidgetsModel.GO_DISABLE_WIDGETS) {
return;
}
-
+ if (FeatureFlags.ENABLE_CACHED_WIDGET.get()) {
+ // Cache the content from the widgets when Launcher stops listening to widget updates
+ final LauncherAppState state = LauncherAppState.getInstance(mContext);
+ synchronized (state.mCachedRemoteViews) {
+ for (int i = 0; i < mViews.size(); i++) {
+ final int appWidgetId = mViews.keyAt(i);
+ final LauncherAppWidgetHostView view = mViews.get(appWidgetId);
+ state.mCachedRemoteViews.put(appWidgetId, view.mLastRemoteViews);
+ }
+ }
+ }
mWidgetHost.stopListening();
setListeningFlag(false);
}
@@ -350,23 +365,24 @@
// RemoteViews from system process.
// TODO: have launcher always listens to widget updates in background so that this
// check can be removed altogether.
- if (FeatureFlags.ENABLE_CACHED_WIDGET.get()
- && mCachedRemoteViews.get(appWidgetId) != null) {
- // We've found RemoteViews from cache for this widget, so we will instantiate a
- // widget host view and populate it with the cached RemoteViews.
- final LauncherAppWidgetHostView view = new LauncherAppWidgetHostView(context);
- view.setAppWidget(appWidgetId, appWidget);
- view.updateAppWidget(mCachedRemoteViews.get(appWidgetId));
- mDeferredViews.put(appWidgetId, view);
- mViews.put(appWidgetId, view);
- return view;
- } else {
- // When cache misses, a placeholder for the widget will be returned instead.
- DeferredAppWidgetHostView view = new DeferredAppWidgetHostView(context);
- view.setAppWidget(appWidgetId, appWidget);
- mViews.put(appWidgetId, view);
- return view;
+ if (FeatureFlags.ENABLE_CACHED_WIDGET.get()) {
+ final RemoteViews cachedRemoteViews = getCachedRemoteViews(appWidgetId);
+ if (cachedRemoteViews != null) {
+ // We've found RemoteViews from cache for this widget, so we will instantiate a
+ // widget host view and populate it with the cached RemoteViews.
+ final LauncherAppWidgetHostView view = new LauncherAppWidgetHostView(context);
+ view.setAppWidget(appWidgetId, appWidget);
+ view.updateAppWidget(cachedRemoteViews);
+ mDeferredViews.put(appWidgetId, view);
+ mViews.put(appWidgetId, view);
+ return view;
+ }
}
+ // If cache misses or not enabled, a placeholder for the widget will be returned.
+ DeferredAppWidgetHostView view = new DeferredAppWidgetHostView(context);
+ view.setAppWidget(appWidgetId, appWidget);
+ mViews.put(appWidgetId, view);
+ return view;
} else {
try {
return mWidgetHost.createView(context, appWidgetId, appWidget);
@@ -432,15 +448,8 @@
LauncherAppWidgetHost tempHost = (LauncherAppWidgetHost) mWidgetHost;
tempHost.clearViews();
if (FeatureFlags.ENABLE_CACHED_WIDGET.get()) {
- // First, we clear any previously cached content from existing widgets
- mCachedRemoteViews.clear();
+ // Clear previously cached content from existing widgets
mDeferredViews.clear();
- // Then we proceed to cache the content from the widgets
- for (int i = 0; i < mViews.size(); i++) {
- final int appWidgetId = mViews.keyAt(i);
- final LauncherAppWidgetHostView view = mViews.get(appWidgetId);
- mCachedRemoteViews.put(appWidgetId, view.mLastRemoteViews);
- }
}
mViews.clear();
}
@@ -481,6 +490,14 @@
return (flags & FLAGS_SHOULD_LISTEN) == FLAGS_SHOULD_LISTEN;
}
+ @Nullable
+ private RemoteViews getCachedRemoteViews(int appWidgetId) {
+ final LauncherAppState state = LauncherAppState.getInstance(mContext);
+ synchronized (state.mCachedRemoteViews) {
+ return state.mCachedRemoteViews.get(appWidgetId);
+ }
+ }
+
/**
* Returns the new LauncherWidgetHolder instance
*/