diff --git a/quickstep/res/values-af/strings.xml b/quickstep/res/values-af/strings.xml
index eac8043..22125d7 100644
--- a/quickstep/res/values-af/strings.xml
+++ b/quickstep/res/values-af/strings.xml
@@ -105,7 +105,7 @@
     <string name="toast_split_select_cont_desc" msgid="2119685056059607602">"Verlaat verdeeldeskermkeuse"</string>
     <string name="toast_split_app_unsupported" msgid="2360229567007828914">"Kies nog ’n app as jy verdeelde skerm wil gebruik"</string>
     <string name="blocked_by_policy" msgid="2071401072261365546">"Jou organisasie laat nie hierdie program toe nie"</string>
-    <string name="split_widgets_not_supported" msgid="1355743038053053866">"Legstukke word nie tans ondersteun nie; kies asseblief ’n ander program"</string>
+    <string name="split_widgets_not_supported" msgid="1355743038053053866">"Legstukke word nie tans ondersteun nie; kies asseblief ’n ander app"</string>
     <string name="skip_tutorial_dialog_title" msgid="2725643161260038458">"Slaan navigasietutoriaal oor?"</string>
     <string name="skip_tutorial_dialog_subtitle" msgid="544063326241955662">"Jy kan dit later in die <xliff:g id="NAME">%1$s</xliff:g>-program kry"</string>
     <string name="gesture_tutorial_action_button_label_cancel" msgid="3809842569351264108">"Kanselleer"</string>
diff --git a/quickstep/res/values-fr-rCA/strings.xml b/quickstep/res/values-fr-rCA/strings.xml
index 746bf50..a5ae3df 100644
--- a/quickstep/res/values-fr-rCA/strings.xml
+++ b/quickstep/res/values-fr-rCA/strings.xml
@@ -97,7 +97,7 @@
     <string name="allset_navigation_settings" msgid="4713404605961476027"><annotation id="link">"Paramètres de navigation du système"</annotation></string>
     <string name="action_share" msgid="2648470652637092375">"Partager"</string>
     <string name="action_screenshot" msgid="8171125848358142917">"Capture d\'écran"</string>
-    <string name="action_split" msgid="2098009717623550676">"Partager"</string>
+    <string name="action_split" msgid="2098009717623550676">"Diviser"</string>
     <string name="action_save_app_pair" msgid="5974823919237645229">"Enr. paire d\'applis"</string>
     <string name="toast_split_select_app" msgid="8464310533320556058">"Toucher une autre appli pour partager l\'écran"</string>
     <string name="toast_contextual_split_select_app" msgid="433510957123687090">"Choisir une autre appli pour utiliser l\'Écran divisé"</string>
diff --git a/quickstep/res/values/config.xml b/quickstep/res/values/config.xml
index f3c9467..e8c8505 100644
--- a/quickstep/res/values/config.xml
+++ b/quickstep/res/values/config.xml
@@ -35,7 +35,6 @@
     <string name="launcher_restore_event_logger_class" translatable="false">com.android.quickstep.LauncherRestoreEventLoggerImpl</string>
     <string name="taskbar_edu_tooltip_controller_class" translatable="false">com.android.launcher3.taskbar.TaskbarEduTooltipController</string>
     <string name="nav_handle_long_press_handler_class" translatable="false"></string>
-    <string name="contextual_search_invoker_class" translatable="false"></string>
     <string name="contextual_search_state_manager_class" translatable="false"></string>
 
     <!-- The number of thumbnails and icons to keep in the cache. The thumbnail cache size also
diff --git a/quickstep/src/com/android/launcher3/QuickstepTransitionManager.java b/quickstep/src/com/android/launcher3/QuickstepTransitionManager.java
index 7d193aa..2759816 100644
--- a/quickstep/src/com/android/launcher3/QuickstepTransitionManager.java
+++ b/quickstep/src/com/android/launcher3/QuickstepTransitionManager.java
@@ -1567,7 +1567,8 @@
 
     private boolean isFreeformAnimation(RemoteAnimationTarget[] appTargets) {
         return DesktopModeStatus.canEnterDesktopMode(mLauncher.getApplicationContext())
-                && DesktopModeFlags.ENABLE_DESKTOP_WINDOWING_EXIT_TRANSITIONS.isTrue()
+                && (DesktopModeFlags.ENABLE_DESKTOP_WINDOWING_EXIT_TRANSITIONS.isTrue()
+                    || DesktopModeFlags.ENABLE_DESKTOP_WINDOWING_EXIT_TRANSITIONS_BUGFIX.isTrue())
                 && Arrays.stream(appTargets)
                         .anyMatch(app -> app.taskInfo != null && app.taskInfo.isFreeform());
     }
diff --git a/quickstep/src/com/android/launcher3/desktop/DesktopAppLaunchTransitionManager.kt b/quickstep/src/com/android/launcher3/desktop/DesktopAppLaunchTransitionManager.kt
index e32bcd1..645bef6 100644
--- a/quickstep/src/com/android/launcher3/desktop/DesktopAppLaunchTransitionManager.kt
+++ b/quickstep/src/com/android/launcher3/desktop/DesktopAppLaunchTransitionManager.kt
@@ -67,7 +67,8 @@
 
     private fun shouldRegisterTransitions(): Boolean =
         DesktopModeStatus.canEnterDesktopMode(context) &&
-            DesktopModeFlags.ENABLE_DESKTOP_APP_LAUNCH_TRANSITIONS.isTrue
+            (DesktopModeFlags.ENABLE_DESKTOP_APP_LAUNCH_TRANSITIONS.isTrue ||
+                DesktopModeFlags.ENABLE_DESKTOP_APP_LAUNCH_TRANSITIONS_BUGFIX.isTrue)
 
     companion object {
         private fun buildAppLaunchFilter(): TransitionFilter {
diff --git a/quickstep/src/com/android/launcher3/taskbar/KeyboardQuickSwitchView.java b/quickstep/src/com/android/launcher3/taskbar/KeyboardQuickSwitchView.java
index 1967dfd..306443e 100644
--- a/quickstep/src/com/android/launcher3/taskbar/KeyboardQuickSwitchView.java
+++ b/quickstep/src/com/android/launcher3/taskbar/KeyboardQuickSwitchView.java
@@ -35,6 +35,8 @@
 import android.view.animation.Interpolator;
 import android.widget.HorizontalScrollView;
 import android.widget.TextView;
+import android.window.OnBackInvokedDispatcher;
+import android.window.WindowOnBackInvokedDispatcher;
 
 import androidx.annotation.LayoutRes;
 import androidx.annotation.NonNull;
@@ -109,6 +111,8 @@
 
     @Nullable private AnimatorSet mOpenAnimation;
 
+    private boolean mIsBackCallbackRegistered = false;
+
     @Nullable private KeyboardQuickSwitchViewController.ViewCallbacks mViewCallbacks;
 
     public KeyboardQuickSwitchView(@NonNull Context context) {
@@ -158,6 +162,34 @@
         mIsRtl = Utilities.isRtl(resources);
     }
 
+    private void registerOnBackInvokedCallback() {
+        OnBackInvokedDispatcher dispatcher = findOnBackInvokedDispatcher();
+
+        if (isOnBackInvokedCallbackEnabled(dispatcher)
+                && !mIsBackCallbackRegistered) {
+            dispatcher.registerOnBackInvokedCallback(
+                    OnBackInvokedDispatcher.PRIORITY_OVERLAY, mViewCallbacks.onBackInvokedCallback);
+            mIsBackCallbackRegistered = true;
+        }
+    }
+
+    private void unregisterOnBackInvokedCallback() {
+        OnBackInvokedDispatcher dispatcher = findOnBackInvokedDispatcher();
+
+        if (isOnBackInvokedCallbackEnabled(dispatcher)
+                && mIsBackCallbackRegistered) {
+            dispatcher.unregisterOnBackInvokedCallback(
+                    mViewCallbacks.onBackInvokedCallback);
+            mIsBackCallbackRegistered = false;
+        }
+    }
+
+    private boolean isOnBackInvokedCallbackEnabled(OnBackInvokedDispatcher dispatcher) {
+        return dispatcher instanceof WindowOnBackInvokedDispatcher
+                && ((WindowOnBackInvokedDispatcher) dispatcher).isOnBackInvokedCallbackEnabled()
+                && mViewCallbacks != null;
+    }
+
     private KeyboardQuickSwitchTaskView createAndAddTaskView(
             int index,
             boolean isFinalView,
@@ -277,6 +309,7 @@
                 new ViewTreeObserver.OnGlobalLayoutListener() {
                     @Override
                     public void onGlobalLayout() {
+                        registerOnBackInvokedCallback();
                         animateOpen(currentFocusIndexOverride);
 
                         getViewTreeObserver().removeOnGlobalLayoutListener(this);
@@ -293,6 +326,9 @@
     }
 
     void resetViewCallbacks() {
+        // Unregister the back invoked callback after the view is closed and before the
+        // mViewCallbacks is reset.
+        unregisterOnBackInvokedCallback();
         mViewCallbacks = null;
     }
 
diff --git a/quickstep/src/com/android/launcher3/taskbar/KeyboardQuickSwitchViewController.java b/quickstep/src/com/android/launcher3/taskbar/KeyboardQuickSwitchViewController.java
index e623b21..3114bc8 100644
--- a/quickstep/src/com/android/launcher3/taskbar/KeyboardQuickSwitchViewController.java
+++ b/quickstep/src/com/android/launcher3/taskbar/KeyboardQuickSwitchViewController.java
@@ -25,6 +25,7 @@
 import android.view.KeyEvent;
 import android.view.MotionEvent;
 import android.view.animation.AnimationUtils;
+import android.window.OnBackInvokedCallback;
 import android.window.RemoteTransition;
 
 import androidx.annotation.NonNull;
@@ -331,6 +332,7 @@
     }
 
     class ViewCallbacks {
+        public final OnBackInvokedCallback onBackInvokedCallback = () -> closeQuickSwitchView(true);
 
         boolean onKeyUp(int keyCode, KeyEvent event, boolean isRTL, boolean allowTraversal) {
             if (keyCode != KeyEvent.KEYCODE_TAB
diff --git a/quickstep/src/com/android/launcher3/taskbar/LauncherTaskbarUIController.java b/quickstep/src/com/android/launcher3/taskbar/LauncherTaskbarUIController.java
index ae438ab..7d75286 100644
--- a/quickstep/src/com/android/launcher3/taskbar/LauncherTaskbarUIController.java
+++ b/quickstep/src/com/android/launcher3/taskbar/LauncherTaskbarUIController.java
@@ -18,8 +18,8 @@
 import static android.window.DesktopModeFlags.ENABLE_DESKTOP_WINDOWING_WALLPAPER_ACTIVITY;
 
 import static com.android.launcher3.QuickstepTransitionManager.TASKBAR_TO_APP_DURATION;
-import static com.android.launcher3.QuickstepTransitionManager.getTaskbarToHomeDuration;
 import static com.android.launcher3.QuickstepTransitionManager.TRANSIENT_TASKBAR_TRANSITION_DURATION;
+import static com.android.launcher3.QuickstepTransitionManager.getTaskbarToHomeDuration;
 import static com.android.launcher3.statemanager.BaseState.FLAG_NON_INTERACTIVE;
 import static com.android.launcher3.taskbar.TaskbarEduTooltipControllerKt.TOOLTIP_STEP_FEATURES;
 import static com.android.launcher3.taskbar.TaskbarLauncherStateController.FLAG_VISIBLE;
@@ -278,7 +278,8 @@
         if (mControllers.bubbleControllers.isEmpty() || hotseat == null) return;
         boolean hiddenForBubbles =
                 mControllers.bubbleControllers.get().bubbleBarViewController.isHiddenForNoBubbles();
-        hotseat.post(() -> adjustHotseatForBubbleBar(!hiddenForBubbles));
+        if (hiddenForBubbles) return;
+        hotseat.post(() -> adjustHotseatForBubbleBar(/* isBubbleBarVisible= */ true));
     }
 
     /**
diff --git a/quickstep/src/com/android/launcher3/taskbar/ManageWindowsTaskbarShortcut.kt b/quickstep/src/com/android/launcher3/taskbar/ManageWindowsTaskbarShortcut.kt
index 8d1f4f5..2038967 100644
--- a/quickstep/src/com/android/launcher3/taskbar/ManageWindowsTaskbarShortcut.kt
+++ b/quickstep/src/com/android/launcher3/taskbar/ManageWindowsTaskbarShortcut.kt
@@ -113,13 +113,13 @@
     private fun createAndPositionTaskbarShortcut(taskList: ArrayList<Pair<Int, Bitmap?>>) {
         val onIconClickListener =
             ({ taskId: Int? ->
-                taskbarShortcutAllWindowsView.removeFromContainer()
+                taskbarShortcutAllWindowsView.animateClose()
                 if (taskId != null) {
                     SystemUiProxy.INSTANCE.get(target).showDesktopApp(taskId, null)
                 }
             })
 
-        val onOutsideClickListener = { taskbarShortcutAllWindowsView.removeFromContainer() }
+        val onOutsideClickListener = { taskbarShortcutAllWindowsView.animateClose() }
 
         taskbarShortcutAllWindowsView =
             TaskbarShortcutManageWindowsView(
@@ -172,6 +172,7 @@
         init {
             createAndShowMenuView(snapshotList, onIconClickListener, onOutsideClickListener)
             taskbarOverlayContext.dragLayer.addTouchController(this)
+            animateOpen()
         }
 
         /** Adds the carousel menu to the taskbar overlay drag layer */
@@ -245,7 +246,7 @@
                     it.action == MotionEvent.ACTION_DOWN &&
                         !taskbarOverlayContext.dragLayer.isEventOverView(menuView.rootView, it)
                 ) {
-                    removeFromContainer()
+                    animateClose()
                 }
             }
             return false
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarActivityContext.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarActivityContext.java
index 70c61ff..0f639f9 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarActivityContext.java
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarActivityContext.java
@@ -869,7 +869,8 @@
     }
 
     private ActivityOptionsWrapper getActivityLaunchDesktopOptions(ItemInfo info) {
-        if (!DesktopModeFlags.ENABLE_DESKTOP_APP_LAUNCH_TRANSITIONS.isTrue()) {
+        if (!DesktopModeFlags.ENABLE_DESKTOP_APP_LAUNCH_TRANSITIONS.isTrue()
+                && !DesktopModeFlags.ENABLE_DESKTOP_APP_LAUNCH_TRANSITIONS_BUGFIX.isTrue()) {
             return null;
         }
         if (!areDesktopTasksVisible()) {
@@ -1437,7 +1438,9 @@
         BubbleTextView.RunningAppState runningAppState =
                 mControllers.taskbarRecentAppsController.getRunningAppState(taskId);
         return runningAppState == BubbleTextView.RunningAppState.MINIMIZED
-                && DesktopModeFlags.ENABLE_DESKTOP_APP_LAUNCH_ALTTAB_TRANSITIONS.isTrue();
+                && (DesktopModeFlags.ENABLE_DESKTOP_APP_LAUNCH_ALTTAB_TRANSITIONS.isTrue()
+                    || DesktopModeFlags.ENABLE_DESKTOP_APP_LAUNCH_ALTTAB_TRANSITIONS_BUGFIX.isTrue()
+                    );
     }
 
     private RemoteTransition createUnminimizeRemoteTransition() {
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarControllers.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarControllers.java
index db70724..826722d 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarControllers.java
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarControllers.java
@@ -227,7 +227,9 @@
                     bubbleControllers.bubbleBarViewController.getBubbleBarLocation();
             boolean hiddenForBubbles =
                     bubbleControllers.bubbleBarViewController.isHiddenForNoBubbles();
-            uiController.adjustHotseatForBubbleBar(!hiddenForBubbles);
+            if (!hiddenForBubbles) {
+                uiController.adjustHotseatForBubbleBar(/* isBubbleBarVisible= */ true);
+            }
             uiController.onBubbleBarLocationUpdated(location);
         }, () -> uiController.onBubbleBarLocationUpdated(null));
         // Notify that the ui controller has changed
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarEduTooltipController.kt b/quickstep/src/com/android/launcher3/taskbar/TaskbarEduTooltipController.kt
index a89bc3a..26a552e 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarEduTooltipController.kt
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarEduTooltipController.kt
@@ -83,7 +83,7 @@
     protected val activityContext: TaskbarActivityContext = ActivityContext.lookupContext(context)
     open val shouldShowSearchEdu: Boolean
         get() =
-            ContextualSearchInvoker.newInstance(activityContext)
+            ContextualSearchInvoker(activityContext)
                 .runContextualSearchInvocationChecksAndLogFailures()
 
     private val isTooltipEnabled: Boolean
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarManager.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarManager.java
index 4498fea..ff8e4a8 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarManager.java
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarManager.java
@@ -261,7 +261,7 @@
                 SystemUiProxy.INSTANCE.get(mContext),
                 ContextualEduStatsManager.INSTANCE.get(mContext),
                 new Handler(),
-                ContextualSearchInvoker.newInstance(mContext));
+                new ContextualSearchInvoker(mContext));
         mDefaultComponentCallbacks = new ComponentCallbacks() {
             private Configuration mOldConfig = mContext.getResources().getConfiguration();
 
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarViewCallbacksFactory.kt b/quickstep/src/com/android/launcher3/taskbar/TaskbarViewCallbacksFactory.kt
index 704d6cf..17da533 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarViewCallbacksFactory.kt
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarViewCallbacksFactory.kt
@@ -38,7 +38,7 @@
                 super.triggerAllAppsButtonLongClick()
 
                 val contextualSearchInvoked =
-                    ContextualSearchInvoker.newInstance(activity).show(ENTRYPOINT_LONG_PRESS_META)
+                    ContextualSearchInvoker(activity).show(ENTRYPOINT_LONG_PRESS_META)
                 if (contextualSearchInvoked) {
                     val runningPackage =
                         TopTaskTracker.INSTANCE[activity].getCachedTopTask(
@@ -59,8 +59,7 @@
     }
 
     open fun longPressAllAppsToStartContextualSearch(context: Context): Boolean =
-        ContextualSearchInvoker.newInstance(context)
-            .runContextualSearchInvocationChecksAndLogFailures()
+        ContextualSearchInvoker(context).runContextualSearchInvocationChecksAndLogFailures()
 
     companion object {
         @JvmStatic
diff --git a/quickstep/src/com/android/launcher3/taskbar/bubbles/BubbleBarView.java b/quickstep/src/com/android/launcher3/taskbar/bubbles/BubbleBarView.java
index 219a2b3..37c6194 100644
--- a/quickstep/src/com/android/launcher3/taskbar/bubbles/BubbleBarView.java
+++ b/quickstep/src/com/android/launcher3/taskbar/bubbles/BubbleBarView.java
@@ -81,6 +81,7 @@
 
     public static final long FADE_OUT_ANIM_POSITION_DURATION_MS = 100L;
     public static final long FADE_IN_ANIM_ALPHA_DURATION_MS = 100L;
+    public static final long FADE_OUT_BUBBLE_BAR_DURATION_MS = 150L;
     private static final String TAG = "BubbleBarView";
     // TODO: (b/273594744) calculate the amount of space we have and base the max on that
     //  if it's smaller than 5.
@@ -146,6 +147,9 @@
     // collapsed state and 1 to the fully expanded state.
     private ValueAnimator mWidthAnimator = createExpansionAnimator(/* expanding = */ false);
 
+    @Nullable
+    private ValueAnimator mDismissAnimator = null;
+
     /** An animator used for animating individual bubbles in the bubble bar while expanded. */
     @Nullable
     private BubbleAnimator mBubbleAnimator = null;
@@ -798,11 +802,11 @@
     /** Removes the given bubble from the bubble bar. */
     public void removeBubble(View bubble) {
         if (isExpanded()) {
-            // TODO b/347062801 - animate the bubble bar if the last bubble is removed
             final boolean dismissedByDrag = mDraggedBubbleView == bubble;
             if (dismissedByDrag) {
                 mDismissedByDragBubbleView = mDraggedBubbleView;
             }
+            boolean removingLastRemainingBubble = getBubbleChildCount() == 1;
             int bubbleCount = getChildCount();
             mBubbleAnimator = new BubbleAnimator(mIconSize, mExpandedBarIconsSpacing,
                     bubbleCount, mBubbleBarLocation.isOnLeft(isLayoutRtl()));
@@ -840,7 +844,10 @@
                             : bubbleIndex == bubbleCount - 1;
             mBubbleAnimator.animateRemovedBubble(
                     indexOfChild(bubble), indexOfChild(mSelectedBubbleView), removingLastBubble,
-                    listener);
+                    removingLastRemainingBubble, listener);
+            if (removingLastRemainingBubble && mDismissAnimator == null) {
+                createDismissAnimator().start();
+            }
         } else {
             removeView(bubble);
         }
@@ -861,6 +868,28 @@
         updateDotsAndBadgesIfCollapsed();
     }
 
+    private ValueAnimator createDismissAnimator() {
+        ValueAnimator animator =
+                ValueAnimator.ofFloat(0, 1).setDuration(FADE_OUT_BUBBLE_BAR_DURATION_MS);
+        animator.setInterpolator(Interpolators.EMPHASIZED);
+        Runnable onEnd = () -> {
+            mDismissAnimator = null;
+            setAlpha(0);
+        };
+        addAnimationCallBacks(animator, /* onStart= */ null, onEnd,
+                /* onUpdate= */ anim -> setAlpha(1 - anim.getAnimatedFraction()));
+        mDismissAnimator = animator;
+        return animator;
+    }
+
+    /** Dismisses the bubble bar */
+    public void dismiss(Runnable onDismissed) {
+        if (mDismissAnimator == null) {
+            createDismissAnimator().start();
+        }
+        addAnimationCallBacks(mDismissAnimator, null, onDismissed, null);
+    }
+
     /**
      * Return child views in the order which they are shown on the screen.
      * <p>
diff --git a/quickstep/src/com/android/launcher3/taskbar/bubbles/BubbleBarViewController.java b/quickstep/src/com/android/launcher3/taskbar/bubbles/BubbleBarViewController.java
index 1e0a778..67d7901 100644
--- a/quickstep/src/com/android/launcher3/taskbar/bubbles/BubbleBarViewController.java
+++ b/quickstep/src/com/android/launcher3/taskbar/bubbles/BubbleBarViewController.java
@@ -597,13 +597,17 @@
     public void setHiddenForBubbles(boolean hidden) {
         if (mHiddenForNoBubbles != hidden) {
             mHiddenForNoBubbles = hidden;
-            updateVisibilityForStateChange();
             if (hidden) {
-                mBarView.setAlpha(0);
-                mBarView.setExpanded(false);
-                adjustTaskbarAndHotseatToBubbleBarState(/* isBubbleBarExpanded = */ false);
+                mBarView.dismiss(() -> {
+                    updateVisibilityForStateChange();
+                    mBarView.setExpanded(false);
+                    adjustTaskbarAndHotseatToBubbleBarState(/* isBubbleBarExpanded= */ false);
+                    mActivity.bubbleBarVisibilityChanged(/* isVisible= */ false);
+                });
+            } else {
+                updateVisibilityForStateChange();
+                mActivity.bubbleBarVisibilityChanged(/* isVisible= */ true);
             }
-            mActivity.bubbleBarVisibilityChanged(!hidden);
         }
     }
 
@@ -636,7 +640,6 @@
         }
     }
 
-    // TODO: (b/273592694) animate it
     private void updateVisibilityForStateChange() {
         if (!mHiddenForSysui && !mHiddenForNoBubbles && !mHiddenForStashed) {
             mBarView.setVisibility(VISIBLE);
diff --git a/quickstep/src/com/android/launcher3/taskbar/bubbles/animation/BubbleAnimator.kt b/quickstep/src/com/android/launcher3/taskbar/bubbles/animation/BubbleAnimator.kt
index 8af8ffb..3604167 100644
--- a/quickstep/src/com/android/launcher3/taskbar/bubbles/animation/BubbleAnimator.kt
+++ b/quickstep/src/com/android/launcher3/taskbar/bubbles/animation/BubbleAnimator.kt
@@ -49,23 +49,30 @@
         bubbleIndex: Int,
         selectedBubbleIndex: Int,
         removingLastBubble: Boolean,
-        listener: Listener
+        removingLastRemainingBubble: Boolean,
+        listener: Listener,
     ) {
         animator = createAnimator(listener)
-        state = State.RemovingBubble(bubbleIndex, selectedBubbleIndex, removingLastBubble)
+        state =
+            State.RemovingBubble(
+                bubbleIndex = bubbleIndex,
+                selectedBubbleIndex = selectedBubbleIndex,
+                removingLastBubble = removingLastBubble,
+                removingLastRemainingBubble = removingLastRemainingBubble,
+            )
         animator.start()
     }
 
     fun animateNewAndRemoveOld(
         selectedBubbleIndex: Int,
         removedBubbleIndex: Int,
-        listener: Listener
+        listener: Listener,
     ) {
         animator = createAnimator(listener)
         state =
             State.AddingAndRemoving(
                 selectedBubbleIndex = selectedBubbleIndex,
-                removedBubbleIndex = removedBubbleIndex
+                removedBubbleIndex = removedBubbleIndex,
             )
         animator.start()
     }
@@ -111,20 +118,22 @@
                 getBubbleTranslationXWhileScalingBubble(
                     bubbleIndex = bubbleIndex,
                     scalingBubbleIndex = 0,
-                    bubbleScale = animator.animatedFraction
+                    bubbleScale = animator.animatedFraction,
                 )
+
             is State.RemovingBubble ->
                 getBubbleTranslationXWhileScalingBubble(
                     bubbleIndex = bubbleIndex,
                     scalingBubbleIndex = state.bubbleIndex,
-                    bubbleScale = 1 - animator.animatedFraction
+                    bubbleScale = 1 - animator.animatedFraction,
                 )
+
             is State.AddingAndRemoving ->
                 getBubbleTranslationXWhileAddingBubbleAtLimit(
                     bubbleIndex = bubbleIndex,
                     removedBubbleIndex = state.removedBubbleIndex,
                     addedBubbleScale = animator.animatedFraction,
-                    removedBubbleScale = 1 - animator.animatedFraction
+                    removedBubbleScale = 1 - animator.animatedFraction,
                 )
         }
     }
@@ -176,10 +185,11 @@
                     getBubbleTranslationXWhileScalingBubble(
                         bubbleIndex = state.selectedBubbleIndex,
                         scalingBubbleIndex = 0,
-                        bubbleScale = animator.animatedFraction
+                        bubbleScale = animator.animatedFraction,
                     )
                 tx + iconSize / 2f
             }
+
             is State.RemovingBubble -> getArrowPositionWhenRemovingBubble(state)
             is State.AddingAndRemoving -> {
                 // we never remove the selected bubble, so the arrow stays pointing to its center
@@ -188,22 +198,23 @@
                         bubbleIndex = state.selectedBubbleIndex,
                         removedBubbleIndex = state.removedBubbleIndex,
                         addedBubbleScale = animator.animatedFraction,
-                        removedBubbleScale = 1 - animator.animatedFraction
+                        removedBubbleScale = 1 - animator.animatedFraction,
                     )
                 tx + iconSize / 2f
             }
         }
     }
 
-    private fun getArrowPositionWhenRemovingBubble(state: State.RemovingBubble): Float {
-        return if (state.selectedBubbleIndex != state.bubbleIndex) {
-            // if we're not removing the selected bubble, the selected bubble doesn't change so just
-            // return the translation X of the selected bubble and add half icon
+    private fun getArrowPositionWhenRemovingBubble(state: State.RemovingBubble): Float =
+        if (state.selectedBubbleIndex != state.bubbleIndex || state.removingLastRemainingBubble) {
+            // if we're not removing the selected bubble or if we're removing the last remaining
+            // bubble, the selected bubble doesn't change so just return the translation X of the
+            // selected bubble and add half icon
             val tx =
                 getBubbleTranslationXWhileScalingBubble(
                     bubbleIndex = state.selectedBubbleIndex,
                     scalingBubbleIndex = state.bubbleIndex,
-                    bubbleScale = 1 - animator.animatedFraction
+                    bubbleScale = 1 - animator.animatedFraction,
                 )
             tx + iconSize / 2f
         } else {
@@ -238,7 +249,6 @@
                 }
             }
         }
-    }
 
     /**
      * Returns the translation X for the bubble at index {@code bubbleIndex} when the bubble bar is
@@ -251,7 +261,7 @@
     private fun getBubbleTranslationXWhileScalingBubble(
         bubbleIndex: Int,
         scalingBubbleIndex: Int,
-        bubbleScale: Float
+        bubbleScale: Float,
     ): Float {
         val iconAndSpacing = iconSize + expandedBarIconSpacing
         // the bubble is scaling from the center, so we need to adjust its translation so
@@ -300,7 +310,7 @@
         bubbleIndex: Int,
         removedBubbleIndex: Int,
         addedBubbleScale: Float,
-        removedBubbleScale: Float
+        removedBubbleScale: Float,
     ): Float {
         val iconAndSpacing = iconSize + expandedBarIconSpacing
         // the bubbles are scaling from the center, so we need to adjust their translation so
@@ -377,7 +387,9 @@
             /** The index of the selected bubble. */
             val selectedBubbleIndex: Int,
             /** Whether the bubble being removed is also the last bubble. */
-            val removingLastBubble: Boolean
+            val removingLastBubble: Boolean,
+            /** Whether we're removing the last remaining bubble. */
+            val removingLastRemainingBubble: Boolean,
         ) : State
 
         /** A new bubble is being added and an old bubble is being removed from the bubble bar. */
diff --git a/quickstep/src/com/android/launcher3/taskbar/bubbles/animation/BubbleBarViewAnimator.kt b/quickstep/src/com/android/launcher3/taskbar/bubbles/animation/BubbleBarViewAnimator.kt
index f5a6655..6f8943f 100644
--- a/quickstep/src/com/android/launcher3/taskbar/bubbles/animation/BubbleBarViewAnimator.kt
+++ b/quickstep/src/com/android/launcher3/taskbar/bubbles/animation/BubbleBarViewAnimator.kt
@@ -511,23 +511,21 @@
 
     /** Interrupts the animation due to touching the bubble bar or flyout. */
     fun interruptForTouch() {
+        animatingBubble?.hideAnimation?.let { scheduler.cancel(it) }
         PhysicsAnimator.getInstance(bubbleBarView).cancelIfRunning()
         bubbleStashController.getStashedHandlePhysicsAnimator().cancelIfRunning()
         cancelFlyout()
-        val hideAnimation = animatingBubble?.hideAnimation ?: return
-        scheduler.cancel(hideAnimation)
-        bubbleBarView.relativePivotY = 1f
+        resetBubbleBarPropertiesOnInterrupt()
         clearAnimatingBubble()
     }
 
     /** Notifies the animator that the taskbar area was touched during an animation. */
     fun onStashStateChangingWhileAnimating() {
+        animatingBubble?.hideAnimation?.let { scheduler.cancel(it) }
         cancelFlyout()
-        val hideAnimation = animatingBubble?.hideAnimation ?: return
-        scheduler.cancel(hideAnimation)
         clearAnimatingBubble()
         bubbleStashController.getStashedHandlePhysicsAnimator().cancelIfRunning()
-        bubbleBarView.relativePivotY = 1f
+        resetBubbleBarPropertiesOnInterrupt()
         bubbleStashController.onNewBubbleAnimationInterrupted(
             /* isStashed= */ bubbleBarView.alpha == 0f,
             bubbleBarView.translationY,
@@ -541,7 +539,7 @@
         scheduler.cancel(hideAnimation)
         animatingBubble = null
         bubbleStashController.getStashedHandlePhysicsAnimator().cancelIfRunning()
-        bubbleBarView.relativePivotY = 1f
+        resetBubbleBarPropertiesOnInterrupt()
         // stash the bubble bar since the IME is now visible
         bubbleStashController.onNewBubbleAnimationInterrupted(
             /* isStashed= */ true,
@@ -679,6 +677,12 @@
         bubbleStashController.showBubbleBarImmediate()
     }
 
+    private fun resetBubbleBarPropertiesOnInterrupt() {
+        bubbleBarView.relativePivotY = 1f
+        bubbleBarView.scaleX = 1f
+        bubbleBarView.scaleY = 1f
+    }
+
     private fun <T> PhysicsAnimator<T>?.cancelIfRunning() {
         if (this?.isRunning() == true) cancel()
     }
diff --git a/quickstep/src/com/android/quickstep/SystemUiProxy.java b/quickstep/src/com/android/quickstep/SystemUiProxy.java
index 6c4c74c..2991e64 100644
--- a/quickstep/src/com/android/quickstep/SystemUiProxy.java
+++ b/quickstep/src/com/android/quickstep/SystemUiProxy.java
@@ -55,6 +55,7 @@
 
 import androidx.annotation.MainThread;
 import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
 import androidx.annotation.WorkerThread;
 
 import com.android.internal.logging.InstanceId;
@@ -70,6 +71,7 @@
 import com.android.quickstep.util.unfold.ProxyUnfoldTransitionProvider;
 import com.android.systemui.shared.recents.ISystemUiProxy;
 import com.android.systemui.shared.recents.model.ThumbnailData;
+import com.android.systemui.shared.system.QuickStepContract;
 import com.android.systemui.shared.system.QuickStepContract.SystemUiStateFlags;
 import com.android.systemui.shared.system.RecentsAnimationControllerCompat;
 import com.android.systemui.shared.system.RecentsAnimationListener;
@@ -313,7 +315,7 @@
         setBackToLauncherCallback(mBackToLauncherCallback, mBackToLauncherRunner);
         setUnfoldAnimationListener(mUnfoldAnimationListener);
         setDesktopTaskListener(mDesktopTaskListener);
-        setAssistantOverridesRequested(ContextualSearchInvoker.newInstance(mContext)
+        setAssistantOverridesRequested(new ContextualSearchInvoker(mContext)
                 .getSysUiAssistOverrideInvocationTypes());
         mStateChangeCallbacks.forEach(Runnable::run);
 
@@ -1634,4 +1636,24 @@
         pw.println("\tmUnfoldAnimationListener=" + mUnfoldAnimationListener);
         pw.println("\tmDragAndDrop=" + mDragAndDrop);
     }
+
+    /**
+     * Adds all interfaces held by this proxy to the bundle
+     */
+    @VisibleForTesting
+    public void addAllInterfaces(Bundle out) {
+        QuickStepContract.addInterface(mSystemUiProxy, out);
+        QuickStepContract.addInterface(mPip, out);
+        QuickStepContract.addInterface(mBubbles, out);
+        QuickStepContract.addInterface(mSysuiUnlockAnimationController, out);
+        QuickStepContract.addInterface(mSplitScreen, out);
+        QuickStepContract.addInterface(mOneHanded, out);
+        QuickStepContract.addInterface(mShellTransitions, out);
+        QuickStepContract.addInterface(mStartingWindow, out);
+        QuickStepContract.addInterface(mRecentTasks, out);
+        QuickStepContract.addInterface(mBackAnimation, out);
+        QuickStepContract.addInterface(mDesktopMode, out);
+        QuickStepContract.addInterface(mUnfoldAnimation, out);
+        QuickStepContract.addInterface(mDragAndDrop, out);
+    }
 }
diff --git a/quickstep/src/com/android/quickstep/TouchInteractionService.java b/quickstep/src/com/android/quickstep/TouchInteractionService.java
index 8edb16f..50d4dab 100644
--- a/quickstep/src/com/android/quickstep/TouchInteractionService.java
+++ b/quickstep/src/com/android/quickstep/TouchInteractionService.java
@@ -37,19 +37,6 @@
 import static com.android.quickstep.InputConsumerUtils.newConsumer;
 import static com.android.quickstep.InputConsumerUtils.tryCreateAssistantInputConsumer;
 import static com.android.systemui.shared.system.ActivityManagerWrapper.CLOSE_SYSTEM_WINDOWS_REASON_RECENTS;
-import static com.android.systemui.shared.system.QuickStepContract.KEY_EXTRA_SYSUI_PROXY;
-import static com.android.systemui.shared.system.QuickStepContract.KEY_EXTRA_UNFOLD_ANIMATION_FORWARDER;
-import static com.android.systemui.shared.system.QuickStepContract.KEY_EXTRA_UNLOCK_ANIMATION_CONTROLLER;
-import static com.android.wm.shell.shared.ShellSharedConstants.KEY_EXTRA_SHELL_BACK_ANIMATION;
-import static com.android.wm.shell.shared.ShellSharedConstants.KEY_EXTRA_SHELL_BUBBLES;
-import static com.android.wm.shell.shared.ShellSharedConstants.KEY_EXTRA_SHELL_DESKTOP_MODE;
-import static com.android.wm.shell.shared.ShellSharedConstants.KEY_EXTRA_SHELL_DRAG_AND_DROP;
-import static com.android.wm.shell.shared.ShellSharedConstants.KEY_EXTRA_SHELL_ONE_HANDED;
-import static com.android.wm.shell.shared.ShellSharedConstants.KEY_EXTRA_SHELL_PIP;
-import static com.android.wm.shell.shared.ShellSharedConstants.KEY_EXTRA_SHELL_RECENT_TASKS;
-import static com.android.wm.shell.shared.ShellSharedConstants.KEY_EXTRA_SHELL_SHELL_TRANSITIONS;
-import static com.android.wm.shell.shared.ShellSharedConstants.KEY_EXTRA_SHELL_SPLIT_SCREEN;
-import static com.android.wm.shell.shared.ShellSharedConstants.KEY_EXTRA_SHELL_STARTING_WINDOW;
 
 import android.app.PendingIntent;
 import android.app.Service;
@@ -148,7 +135,6 @@
 public class TouchInteractionService extends Service {
 
     private static final String SUBSTRING_PREFIX = "; ";
-    private static final String NEWLINE_PREFIX = "\n\t\t\t-> ";
 
     private static final String TAG = "TouchInteractionService";
 
@@ -173,30 +159,30 @@
         @BinderThread
         public void onInitialize(Bundle bundle) {
             ISystemUiProxy proxy = ISystemUiProxy.Stub.asInterface(
-                    bundle.getBinder(KEY_EXTRA_SYSUI_PROXY));
-            IPip pip = IPip.Stub.asInterface(bundle.getBinder(KEY_EXTRA_SHELL_PIP));
-            IBubbles bubbles = IBubbles.Stub.asInterface(bundle.getBinder(KEY_EXTRA_SHELL_BUBBLES));
+                    bundle.getBinder(ISystemUiProxy.DESCRIPTOR));
+            IPip pip = IPip.Stub.asInterface(bundle.getBinder(IPip.DESCRIPTOR));
+            IBubbles bubbles = IBubbles.Stub.asInterface(bundle.getBinder(IBubbles.DESCRIPTOR));
             ISplitScreen splitscreen = ISplitScreen.Stub.asInterface(bundle.getBinder(
-                    KEY_EXTRA_SHELL_SPLIT_SCREEN));
+                    ISplitScreen.DESCRIPTOR));
             IOneHanded onehanded = IOneHanded.Stub.asInterface(
-                    bundle.getBinder(KEY_EXTRA_SHELL_ONE_HANDED));
+                    bundle.getBinder(IOneHanded.DESCRIPTOR));
             IShellTransitions shellTransitions = IShellTransitions.Stub.asInterface(
-                    bundle.getBinder(KEY_EXTRA_SHELL_SHELL_TRANSITIONS));
+                    bundle.getBinder(IShellTransitions.DESCRIPTOR));
             IStartingWindow startingWindow = IStartingWindow.Stub.asInterface(
-                    bundle.getBinder(KEY_EXTRA_SHELL_STARTING_WINDOW));
+                    bundle.getBinder(IStartingWindow.DESCRIPTOR));
             ISysuiUnlockAnimationController launcherUnlockAnimationController =
                     ISysuiUnlockAnimationController.Stub.asInterface(
-                            bundle.getBinder(KEY_EXTRA_UNLOCK_ANIMATION_CONTROLLER));
+                            bundle.getBinder(ISysuiUnlockAnimationController.DESCRIPTOR));
             IRecentTasks recentTasks = IRecentTasks.Stub.asInterface(
-                    bundle.getBinder(KEY_EXTRA_SHELL_RECENT_TASKS));
+                    bundle.getBinder(IRecentTasks.DESCRIPTOR));
             IBackAnimation backAnimation = IBackAnimation.Stub.asInterface(
-                    bundle.getBinder(KEY_EXTRA_SHELL_BACK_ANIMATION));
+                    bundle.getBinder(IBackAnimation.DESCRIPTOR));
             IDesktopMode desktopMode = IDesktopMode.Stub.asInterface(
-                    bundle.getBinder(KEY_EXTRA_SHELL_DESKTOP_MODE));
+                    bundle.getBinder(IDesktopMode.DESCRIPTOR));
             IUnfoldAnimation unfoldTransition = IUnfoldAnimation.Stub.asInterface(
-                    bundle.getBinder(KEY_EXTRA_UNFOLD_ANIMATION_FORWARDER));
+                    bundle.getBinder(IUnfoldAnimation.DESCRIPTOR));
             IDragAndDrop dragAndDrop = IDragAndDrop.Stub.asInterface(
-                    bundle.getBinder(KEY_EXTRA_SHELL_DRAG_AND_DROP));
+                    bundle.getBinder(IDragAndDrop.DESCRIPTOR));
             MAIN_EXECUTOR.execute(() -> executeForTouchInteractionService(tis -> {
                 SystemUiProxy.INSTANCE.get(tis).setProxy(proxy, pip,
                         bubbles, splitscreen, onehanded, shellTransitions, startingWindow,
@@ -286,8 +272,7 @@
         @Override
         public void onAssistantOverrideInvoked(int invocationType) {
             executeForTouchInteractionService(tis -> {
-                if (!ContextualSearchInvoker.newInstance(tis)
-                        .tryStartAssistOverride(invocationType)) {
+                if (!new ContextualSearchInvoker(tis).tryStartAssistOverride(invocationType)) {
                     Log.w(TAG, "Failed to invoke Assist override");
                 }
             });
@@ -524,7 +509,8 @@
         }
 
         protected void onOverviewTargetChange() {
-            for (Runnable listener : mOnOverviewTargetChangeListeners) {
+            Set<Runnable> listeners = new HashSet<>(mOnOverviewTargetChangeListeners);
+            for (Runnable listener : listeners) {
                 listener.run();
             }
         }
diff --git a/quickstep/src/com/android/quickstep/fallback/window/RecentsWindowManager.kt b/quickstep/src/com/android/quickstep/fallback/window/RecentsWindowManager.kt
index e158975..86f9829 100644
--- a/quickstep/src/com/android/quickstep/fallback/window/RecentsWindowManager.kt
+++ b/quickstep/src/com/android/quickstep/fallback/window/RecentsWindowManager.kt
@@ -36,11 +36,13 @@
 import com.android.launcher3.LauncherAnimationRunner
 import com.android.launcher3.LauncherAnimationRunner.RemoteAnimationFactory
 import com.android.launcher3.R
+import com.android.launcher3.compat.AccessibilityManagerCompat
 import com.android.launcher3.statehandlers.DesktopVisibilityController
 import com.android.launcher3.statemanager.StateManager
 import com.android.launcher3.statemanager.StateManager.AtomicAnimationFactory
 import com.android.launcher3.statemanager.StatefulContainer
 import com.android.launcher3.taskbar.TaskbarUIController
+import com.android.launcher3.testing.shared.TestProtocol.OVERVIEW_STATE_ORDINAL
 import com.android.launcher3.util.ContextTracker
 import com.android.launcher3.util.DisplayController
 import com.android.launcher3.util.RunnableList
@@ -355,6 +357,9 @@
         if (state == HOME || state == BG_LAUNCHER) {
             cleanupRecentsWindow()
         }
+        if (state === DEFAULT) {
+            AccessibilityManagerCompat.sendStateEventToTest(baseContext, OVERVIEW_STATE_ORDINAL)
+        }
     }
 
     private fun getStateName(state: RecentsState?): String {
diff --git a/quickstep/src/com/android/quickstep/inputconsumers/NavHandleLongPressHandler.java b/quickstep/src/com/android/quickstep/inputconsumers/NavHandleLongPressHandler.java
index 155d095..107babd 100644
--- a/quickstep/src/com/android/quickstep/inputconsumers/NavHandleLongPressHandler.java
+++ b/quickstep/src/com/android/quickstep/inputconsumers/NavHandleLongPressHandler.java
@@ -62,7 +62,7 @@
         mStatsLogManager = StatsLogManager.newInstance(context);
         mVibratorWrapper = VibratorWrapper.INSTANCE.get(mContext);
         mContextualSearchHapticManager = ContextualSearchHapticManager.INSTANCE.get(context);
-        mContextualSearchInvoker = ContextualSearchInvoker.newInstance(mContext);
+        mContextualSearchInvoker = new ContextualSearchInvoker(mContext);
     }
 
     /** Creates NavHandleLongPressHandler as specified by overrides */
diff --git a/quickstep/src/com/android/quickstep/interaction/AllSetActivity.java b/quickstep/src/com/android/quickstep/interaction/AllSetActivity.java
index 3eba9c0..99c2c1c 100644
--- a/quickstep/src/com/android/quickstep/interaction/AllSetActivity.java
+++ b/quickstep/src/com/android/quickstep/interaction/AllSetActivity.java
@@ -195,7 +195,7 @@
                         LOTTIE_TERTIARY_COLOR_TOKEN, R.color.all_set_bg_tertiary),
                 getTheme());
 
-        startBackgroundAnimation(getDP().isTablet);
+        setUpBackgroundAnimation(getDP().isTablet);
         getIDP().addOnChangeListener(mOnIDPChangeListener);
     }
 
@@ -220,7 +220,7 @@
         Executors.UI_HELPER_EXECUTOR.execute(runnable);
     }
 
-    private void startBackgroundAnimation(boolean forTablet) {
+    private void setUpBackgroundAnimation(boolean forTablet) {
         if (mVibrator == null) {
             return;
         }
@@ -264,7 +264,6 @@
                     };
         }
         mAnimatedBackground.addAnimatorListener(mBackgroundAnimatorListener);
-        mAnimatedBackground.playAnimation();
     }
 
     private void setSetupUIVisible(boolean visible) {
diff --git a/quickstep/src/com/android/quickstep/util/ContextualSearchInvoker.kt b/quickstep/src/com/android/quickstep/util/ContextualSearchInvoker.kt
index bd454c0..3be8ea6 100644
--- a/quickstep/src/com/android/quickstep/util/ContextualSearchInvoker.kt
+++ b/quickstep/src/com/android/quickstep/util/ContextualSearchInvoker.kt
@@ -21,8 +21,8 @@
 import android.app.contextualsearch.ContextualSearchManager.FEATURE_CONTEXTUAL_SEARCH
 import android.content.Context
 import android.util.Log
+import androidx.annotation.VisibleForTesting
 import com.android.internal.app.AssistUtils
-import com.android.launcher3.R
 import com.android.launcher3.logging.StatsLogManager
 import com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_LAUNCH_ASSISTANT_FAILED_SERVICE_ERROR
 import com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_LAUNCH_OMNI_ATTEMPTED_OVER_KEYGUARD
@@ -31,23 +31,26 @@
 import com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_LAUNCH_OMNI_FAILED_NOT_AVAILABLE
 import com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_LAUNCH_OMNI_FAILED_SETTING_DISABLED
 import com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_LAUNCH_OMNI_SUCCESSFUL_HOME
-import com.android.launcher3.util.ResourceBasedOverride
+import com.android.quickstep.BaseContainerInterface
 import com.android.quickstep.DeviceConfigWrapper
+import com.android.quickstep.OverviewComponentObserver
+import com.android.quickstep.RecentsAnimationDeviceState
 import com.android.quickstep.SystemUiProxy
 import com.android.quickstep.TopTaskTracker
+import com.android.quickstep.views.RecentsView
 import com.android.systemui.shared.system.QuickStepContract
 
 /** Handles invocations and checks for Contextual Search. */
-open class ContextualSearchInvoker
+class ContextualSearchInvoker
 internal constructor(
-    protected val context: Context,
+    private val context: Context,
     private val contextualSearchStateManager: ContextualSearchStateManager,
     private val topTaskTracker: TopTaskTracker,
     private val systemUiProxy: SystemUiProxy,
-    protected val statsLogManager: StatsLogManager,
+    private val statsLogManager: StatsLogManager,
     private val contextualSearchHapticManager: ContextualSearchHapticManager,
     private val contextualSearchManager: ContextualSearchManager?,
-) : ResourceBasedOverride {
+) {
     constructor(
         context: Context
     ) : this(
@@ -61,7 +64,7 @@
     )
 
     /** @return Array of AssistUtils.INVOCATION_TYPE_* that we want to handle instead of SysUI. */
-    open fun getSysUiAssistOverrideInvocationTypes(): IntArray {
+    fun getSysUiAssistOverrideInvocationTypes(): IntArray {
         val overrideInvocationTypes = com.android.launcher3.util.IntArray()
         if (context.packageManager.hasSystemFeature(FEATURE_CONTEXTUAL_SEARCH)) {
             overrideInvocationTypes.add(AssistUtils.INVOCATION_TYPE_HOME_BUTTON_LONG_PRESS)
@@ -183,7 +186,15 @@
         if (contextualSearchManager == null) {
             return false
         }
-        contextualSearchManager.startContextualSearch(entryPoint)
+        val recentsContainerInterface = getRecentsContainerInterface()
+        if (recentsContainerInterface?.isInLiveTileMode() == true) {
+            Log.i(TAG, "Contextual Search invocation attempted: live tile")
+            endLiveTileMode(recentsContainerInterface) {
+                contextualSearchManager.startContextualSearch(entryPoint)
+            }
+        } else {
+            contextualSearchManager.startContextualSearch(entryPoint)
+        }
         return true
     }
 
@@ -199,6 +210,42 @@
         return systemUiProxy.lastSystemUiStateFlags and KEYGUARD_SHOWING_SYSUI_FLAGS != 0L
     }
 
+    @VisibleForTesting
+    fun getRecentsContainerInterface(): BaseContainerInterface<*, *>? {
+        val rads = RecentsAnimationDeviceState(context)
+        val observer = OverviewComponentObserver(context, rads)
+        try {
+            return observer.containerInterface
+        } finally {
+            observer.onDestroy()
+            rads.destroy()
+        }
+    }
+
+    /**
+     * End the live tile mode.
+     *
+     * @param onCompleteRunnable Runnable to run when the live tile is paused. May run immediately.
+     */
+    private fun endLiveTileMode(
+        recentsContainerInterface: BaseContainerInterface<*, *>?,
+        onCompleteRunnable: Runnable,
+    ) {
+        val recentsViewContainer = recentsContainerInterface?.createdContainer
+        if (recentsViewContainer == null) {
+            onCompleteRunnable.run()
+            return
+        }
+        val recentsView: RecentsView<*, *> = recentsViewContainer.getOverviewPanel()
+        recentsView.switchToScreenshot {
+            recentsView.finishRecentsAnimation(
+                true, /* toRecents */
+                false, /* shouldPip */
+                onCompleteRunnable,
+            )
+        }
+    }
+
     companion object {
         private const val TAG = "ContextualSearchInvoker"
         const val SHADE_EXPANDED_SYSUI_FLAGS =
@@ -208,14 +255,5 @@
             (QuickStepContract.SYSUI_STATE_BOUNCER_SHOWING or
                 QuickStepContract.SYSUI_STATE_STATUS_BAR_KEYGUARD_SHOWING or
                 QuickStepContract.SYSUI_STATE_STATUS_BAR_KEYGUARD_SHOWING_OCCLUDED)
-
-        @JvmStatic
-        fun newInstance(context: Context): ContextualSearchInvoker {
-            return ResourceBasedOverride.Overrides.getObject(
-                ContextualSearchInvoker::class.java,
-                context,
-                R.string.contextual_search_invoker_class,
-            )
-        }
     }
 }
diff --git a/quickstep/src/com/android/quickstep/util/ContextualSearchStateManager.java b/quickstep/src/com/android/quickstep/util/ContextualSearchStateManager.java
index 334ff06..f75d3b3 100644
--- a/quickstep/src/com/android/quickstep/util/ContextualSearchStateManager.java
+++ b/quickstep/src/com/android/quickstep/util/ContextualSearchStateManager.java
@@ -224,7 +224,7 @@
                 UI_HELPER_EXECUTOR.getHandler().postDelayed(
                         () -> {
                             boolean contextualSearchInvoked =
-                                    ContextualSearchInvoker.newInstance(mContext).show(
+                                    new ContextualSearchInvoker(mContext).show(
                                             ENTRYPOINT_SYSTEM_ACTION);
                             if (contextualSearchInvoked) {
                                 String runningPackage =
diff --git a/quickstep/src/com/android/quickstep/views/TaskView.kt b/quickstep/src/com/android/quickstep/views/TaskView.kt
index 3586dfb..082971c 100644
--- a/quickstep/src/com/android/quickstep/views/TaskView.kt
+++ b/quickstep/src/com/android/quickstep/views/TaskView.kt
@@ -1566,6 +1566,7 @@
     }
 
     private fun onModalnessUpdated(modalness: Float) {
+        isClickable = modalness == 0f
         taskContainers.forEach {
             it.iconView.setModalAlpha(1 - modalness)
             it.digitalWellBeingToast?.bannerOffsetPercentage = modalness
diff --git a/quickstep/tests/multivalentTests/src/com/android/launcher3/model/data/TaskViewItemInfoTest.kt b/quickstep/tests/multivalentTests/src/com/android/launcher3/model/data/TaskViewItemInfoTest.kt
index 0103e7e..5cee434 100644
--- a/quickstep/tests/multivalentTests/src/com/android/launcher3/model/data/TaskViewItemInfoTest.kt
+++ b/quickstep/tests/multivalentTests/src/com/android/launcher3/model/data/TaskViewItemInfoTest.kt
@@ -17,14 +17,17 @@
 package com.android.launcher3.model.data
 
 import android.content.ComponentName
-import android.content.Context
 import android.content.Intent
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import androidx.test.platform.app.InstrumentationRegistry
 import com.android.launcher3.Flags.enableRefactorTaskThumbnail
+import com.android.launcher3.model.data.ItemInfoWithIcon.FLAG_NOT_PINNABLE
 import com.android.launcher3.model.data.TaskViewItemInfo.Companion.createTaskViewAtom
+import com.android.launcher3.pm.UserCache
+import com.android.launcher3.util.MainThreadInitializedObject.SandboxContext
 import com.android.launcher3.util.SplitConfigurationOptions
 import com.android.launcher3.util.TransformingTouchDelegate
+import com.android.launcher3.util.UserIconInfo
 import com.android.quickstep.TaskOverlayFactory
 import com.android.quickstep.TaskOverlayFactory.TaskOverlay
 import com.android.quickstep.recents.di.RecentsDependencies
@@ -48,10 +51,12 @@
 /** Test for [TaskViewItemInfo] */
 @RunWith(AndroidJUnit4::class)
 class TaskViewItemInfoTest {
-    private val context = mock<Context>()
+    private val context = SandboxContext(InstrumentationRegistry.getInstrumentation().targetContext)
     private val taskView = mock<TaskView>()
     private val recentsView = mock<RecentsView<*, *>>()
     private val overlayFactory = mock<TaskOverlayFactory>()
+    private val userCache = mock<UserCache>()
+    private val userInfo = mock<UserIconInfo>()
 
     @Before
     fun setUp() {
@@ -59,7 +64,10 @@
         whenever(taskView.context).thenReturn(context)
         whenever(taskView.recentsView).thenReturn(recentsView)
         whenever(recentsView.indexOfChild(taskView)).thenReturn(TASK_VIEW_INDEX)
-        RecentsDependencies.initialize(InstrumentationRegistry.getInstrumentation().targetContext)
+        whenever(userInfo.isPrivate).thenReturn(false)
+        whenever(userCache.getUserInfo(any())).thenReturn(userInfo)
+        context.putObject(UserCache.INSTANCE, userCache)
+        RecentsDependencies.initialize(context)
     }
 
     @Test
@@ -69,9 +77,8 @@
         whenever(taskView.taskContainers).thenReturn(taskContainers)
 
         val taskViewItemInfo = TaskViewItemInfo(taskContainers[0])
-        val taskViewAtom = taskViewItemInfo.taskViewAtom
 
-        assertThat(taskViewAtom)
+        assertThat(taskViewItemInfo.taskViewAtom)
             .isEqualTo(
                 createTaskViewAtom(
                     type = 0,
@@ -80,6 +87,7 @@
                     cardinality = 1,
                 )
             )
+        assertThat(taskViewItemInfo.runtimeStatusFlags and FLAG_NOT_PINNABLE).isEqualTo(0)
     }
 
     @Test
@@ -90,9 +98,8 @@
         whenever(taskView.taskContainers).thenReturn(taskContainers)
 
         val taskViewItemInfo = TaskViewItemInfo(taskContainers[0])
-        val taskViewAtom = taskViewItemInfo.taskViewAtom
 
-        assertThat(taskViewAtom)
+        assertThat(taskViewItemInfo.taskViewAtom)
             .isEqualTo(
                 createTaskViewAtom(
                     type = 1,
@@ -101,6 +108,7 @@
                     cardinality = 2,
                 )
             )
+        assertThat(taskViewItemInfo.runtimeStatusFlags and FLAG_NOT_PINNABLE).isEqualTo(0)
     }
 
     @Test
@@ -115,9 +123,8 @@
         whenever(taskView.taskContainers).thenReturn(taskContainers)
 
         val taskViewItemInfo = TaskViewItemInfo(taskContainers[0])
-        val taskViewAtom = taskViewItemInfo.taskViewAtom
 
-        assertThat(taskViewAtom)
+        assertThat(taskViewItemInfo.taskViewAtom)
             .isEqualTo(
                 createTaskViewAtom(
                     type = 2,
@@ -126,6 +133,29 @@
                     cardinality = 3,
                 )
             )
+        assertThat(taskViewItemInfo.runtimeStatusFlags and FLAG_NOT_PINNABLE).isEqualTo(0)
+    }
+
+    @Test
+    fun privateTask() {
+        val taskContainers = listOf(createTaskContainer(createTask(1)))
+        whenever(taskView.type).thenReturn(TaskViewType.SINGLE)
+        whenever(taskView.taskContainers).thenReturn(taskContainers)
+        whenever(userInfo.isPrivate).thenReturn(true)
+
+        val taskViewItemInfo = TaskViewItemInfo(taskContainers[0])
+
+        assertThat(taskViewItemInfo.taskViewAtom)
+            .isEqualTo(
+                createTaskViewAtom(
+                    type = 0,
+                    index = TASK_VIEW_INDEX,
+                    componentName = "${PACKAGE}/${CLASS}",
+                    cardinality = 1,
+                )
+            )
+        assertThat(taskViewItemInfo.runtimeStatusFlags and FLAG_NOT_PINNABLE)
+            .isEqualTo(FLAG_NOT_PINNABLE)
     }
 
     private fun createTask(id: Int) =
diff --git a/quickstep/tests/multivalentTests/src/com/android/launcher3/taskbar/TaskbarOverflowTest.kt b/quickstep/tests/multivalentTests/src/com/android/launcher3/taskbar/TaskbarOverflowTest.kt
index 5867e77..011ba7e 100644
--- a/quickstep/tests/multivalentTests/src/com/android/launcher3/taskbar/TaskbarOverflowTest.kt
+++ b/quickstep/tests/multivalentTests/src/com/android/launcher3/taskbar/TaskbarOverflowTest.kt
@@ -16,6 +16,7 @@
 
 package com.android.launcher3.taskbar
 
+import android.animation.AnimatorTestRule
 import android.content.ComponentName
 import android.content.Intent
 import android.platform.test.annotations.EnableFlags
@@ -75,7 +76,9 @@
 
     @get:Rule(order = 3) val taskbarModeRule = TaskbarModeRule(context)
 
-    @get:Rule(order = 4) val taskbarUnitTestRule = TaskbarUnitTestRule(this, context)
+    @get:Rule(order = 4) val animatorTestRule = AnimatorTestRule(this)
+
+    @get:Rule(order = 5) val taskbarUnitTestRule = TaskbarUnitTestRule(this, context)
 
     @InjectController lateinit var taskbarViewController: TaskbarViewController
     @InjectController lateinit var recentAppsController: TaskbarRecentAppsController
@@ -208,7 +211,10 @@
         val initialNumIcons = currentNumberOfTaskbarIcons
         val initialMaxNumIconViews = addRunningAppsAndVerifyOverflowState(5)
 
-        runOnMainSync { bubbleBarViewController.setHiddenForBubbles(true) }
+        runOnMainSync {
+            bubbleBarViewController.setHiddenForBubbles(true)
+            animatorTestRule.advanceTimeBy(150)
+        }
 
         val maxNumIconViews = maxNumberOfTaskbarIcons
         assertThat(maxNumIconViews).isGreaterThan(initialMaxNumIconViews)
@@ -226,7 +232,10 @@
         val initialNumIcons = currentNumberOfTaskbarIcons
         val initialMaxNumIconViews = addRunningAppsAndVerifyOverflowState(5)
 
-        runOnMainSync { bubbleBarViewController.setHiddenForBubbles(true) }
+        runOnMainSync {
+            bubbleBarViewController.setHiddenForBubbles(true)
+            animatorTestRule.advanceTimeBy(150)
+        }
 
         val maxNumIconViews = maxNumberOfTaskbarIcons
         assertThat(maxNumIconViews).isGreaterThan(initialMaxNumIconViews)
diff --git a/quickstep/tests/multivalentTests/src/com/android/launcher3/taskbar/bubbles/animation/BubbleAnimatorTest.kt b/quickstep/tests/multivalentTests/src/com/android/launcher3/taskbar/bubbles/animation/BubbleAnimatorTest.kt
index d5a76a2..eae181f 100644
--- a/quickstep/tests/multivalentTests/src/com/android/launcher3/taskbar/bubbles/animation/BubbleAnimatorTest.kt
+++ b/quickstep/tests/multivalentTests/src/com/android/launcher3/taskbar/bubbles/animation/BubbleAnimatorTest.kt
@@ -40,7 +40,7 @@
                 iconSize = 40f,
                 expandedBarIconSpacing = 10f,
                 bubbleCount = 5,
-                onLeft = false
+                onLeft = false,
             )
         val listener = TestBubbleAnimatorListener()
         InstrumentationRegistry.getInstrumentation().runOnMainSync {
@@ -61,7 +61,7 @@
                 iconSize = 40f,
                 expandedBarIconSpacing = 10f,
                 bubbleCount = 5,
-                onLeft = false
+                onLeft = false,
             )
         val listener = TestBubbleAnimatorListener()
         InstrumentationRegistry.getInstrumentation().runOnMainSync {
@@ -69,7 +69,8 @@
                 bubbleIndex = 2,
                 selectedBubbleIndex = 3,
                 removingLastBubble = false,
-                listener
+                removingLastRemainingBubble = false,
+                listener,
             )
         }
 
@@ -87,14 +88,14 @@
                 iconSize = 40f,
                 expandedBarIconSpacing = 10f,
                 bubbleCount = 5,
-                onLeft = false
+                onLeft = false,
             )
         val listener = TestBubbleAnimatorListener()
         InstrumentationRegistry.getInstrumentation().runOnMainSync {
             bubbleAnimator.animateNewAndRemoveOld(
                 selectedBubbleIndex = 3,
                 removedBubbleIndex = 2,
-                listener
+                listener,
             )
         }
 
diff --git a/quickstep/tests/multivalentTests/src/com/android/launcher3/taskbar/bubbles/animation/BubbleBarViewAnimatorTest.kt b/quickstep/tests/multivalentTests/src/com/android/launcher3/taskbar/bubbles/animation/BubbleBarViewAnimatorTest.kt
index 29d142f..06227e2 100644
--- a/quickstep/tests/multivalentTests/src/com/android/launcher3/taskbar/bubbles/animation/BubbleBarViewAnimatorTest.kt
+++ b/quickstep/tests/multivalentTests/src/com/android/launcher3/taskbar/bubbles/animation/BubbleBarViewAnimatorTest.kt
@@ -197,6 +197,8 @@
         assertThat(bubbleBarParentViewController.timesInvoked).isEqualTo(2)
         assertThat(animatorScheduler.delayedBlock).isNull()
         assertThat(bubbleBarView.alpha).isEqualTo(1)
+        assertThat(bubbleBarView.scaleX).isEqualTo(1)
+        assertThat(bubbleBarView.scaleY).isEqualTo(1)
         assertThat(bubbleBarView.visibility).isEqualTo(VISIBLE)
         assertThat(bubbleBarView.translationY).isEqualTo(BAR_TRANSLATION_Y_FOR_TASKBAR)
         assertThat(animator.isAnimating).isFalse()
@@ -241,6 +243,8 @@
         // verify that the hide animation was canceled
         assertThat(animatorScheduler.delayedBlock).isNull()
         assertThat(animator.isAnimating).isFalse()
+        assertThat(bubbleBarView.scaleX).isEqualTo(1)
+        assertThat(bubbleBarView.scaleY).isEqualTo(1)
         verify(bubbleStashController).onNewBubbleAnimationInterrupted(any(), any())
 
         // PhysicsAnimatorTestUtils posts the cancellation to the main thread so we need to wait
diff --git a/quickstep/tests/multivalentTests/src/com/android/quickstep/util/ContextualSearchInvokerTest.java b/quickstep/tests/multivalentTests/src/com/android/quickstep/util/ContextualSearchInvokerTest.java
index 543ffe6..88774be 100644
--- a/quickstep/tests/multivalentTests/src/com/android/quickstep/util/ContextualSearchInvokerTest.java
+++ b/quickstep/tests/multivalentTests/src/com/android/quickstep/util/ContextualSearchInvokerTest.java
@@ -31,6 +31,8 @@
 
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.anyInt;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.spy;
@@ -46,13 +48,17 @@
 import androidx.test.filters.SmallTest;
 
 import com.android.launcher3.logging.StatsLogManager;
+import com.android.quickstep.BaseContainerInterface;
 import com.android.quickstep.DeviceConfigWrapper;
 import com.android.quickstep.SystemUiProxy;
 import com.android.quickstep.TopTaskTracker;
+import com.android.quickstep.views.RecentsView;
+import com.android.quickstep.views.RecentsViewContainer;
 
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 
@@ -73,6 +79,9 @@
     private @Mock StatsLogManager.StatsLogger mMockStatsLogger;
     private @Mock ContextualSearchHapticManager mMockContextualSearchHapticManager;
     private @Mock ContextualSearchManager mMockContextualSearchManager;
+    private @Mock BaseContainerInterface mMockContainerInterface;
+    private @Mock RecentsViewContainer mMockRecentsViewContainer;
+    private @Mock RecentsView mMockRecentsView;
     private ContextualSearchInvoker mContextualSearchInvoker;
 
     @Before
@@ -86,10 +95,15 @@
         when(mMockStateManager.isContextualSearchIntentAvailable()).thenReturn(true);
         when(mMockStateManager.isContextualSearchSettingEnabled()).thenReturn(true);
         when(mMockStatsLogManager.logger()).thenReturn(mMockStatsLogger);
+        when(mMockContainerInterface.getCreatedContainer()).thenReturn(mMockRecentsViewContainer);
+        when(mMockRecentsViewContainer.getOverviewPanel()).thenReturn(mMockRecentsView);
 
-        mContextualSearchInvoker = new ContextualSearchInvoker(context, mMockStateManager,
+        mContextualSearchInvoker = spy(new ContextualSearchInvoker(context, mMockStateManager,
                 mMockTopTaskTracker, mMockSystemUiProxy, mMockStatsLogManager,
-                mMockContextualSearchHapticManager, mMockContextualSearchManager);
+                mMockContextualSearchHapticManager, mMockContextualSearchManager
+        ));
+        doReturn(mMockContainerInterface).when(mContextualSearchInvoker)
+                .getRecentsContainerInterface();
     }
 
     @Test
@@ -244,6 +258,64 @@
         }
     }
 
+    @Test
+    public void invokeContextualSearchUncheckedWithHaptic_liveTile() {
+        when(mMockContainerInterface.isInLiveTileMode()).thenReturn(true);
+        ArgumentCaptor<Runnable> switchToScreenshotCaptor = ArgumentCaptor.forClass(Runnable.class);
+        ArgumentCaptor<Runnable> finishRecentsAnimationCaptor =
+                ArgumentCaptor.forClass(Runnable.class);
+
+        assertTrue("Expected invocation unchecked to succeed",
+                mContextualSearchInvoker.invokeContextualSearchUncheckedWithHaptic(
+                        CONTEXTUAL_SEARCH_ENTRY_POINT));
+        verify(mMockRecentsView).switchToScreenshot(switchToScreenshotCaptor.capture());
+        switchToScreenshotCaptor.getValue().run();
+        verify(mMockRecentsView).finishRecentsAnimation(anyBoolean(), anyBoolean(),
+                finishRecentsAnimationCaptor.capture());
+        finishRecentsAnimationCaptor.getValue().run();
+        verify(mMockContextualSearchManager).startContextualSearch(CONTEXTUAL_SEARCH_ENTRY_POINT);
+        verifyNoMoreInteractions(mMockStatsLogManager);
+    }
+
+    @Test
+    public void invokeContextualSearchUncheckedWithHaptic_liveTile_failsToSwitchToScreenshot() {
+        when(mMockContainerInterface.isInLiveTileMode()).thenReturn(true);
+        ArgumentCaptor<Runnable> switchToScreenshotCaptor = ArgumentCaptor.forClass(Runnable.class);
+        ArgumentCaptor<Runnable> finishRecentsAnimationCaptor =
+                ArgumentCaptor.forClass(Runnable.class);
+
+        assertTrue("Expected invocation unchecked to succeed",
+                mContextualSearchInvoker.invokeContextualSearchUncheckedWithHaptic(
+                        CONTEXTUAL_SEARCH_ENTRY_POINT));
+        verify(mMockRecentsView).switchToScreenshot(switchToScreenshotCaptor.capture());
+
+        // Don't run switchToScreenshot's callback. Therefore, recents animation should not finish.
+        verify(mMockRecentsView, never()).finishRecentsAnimation(anyBoolean(), anyBoolean(),
+                finishRecentsAnimationCaptor.capture());
+        // And ContextualSearch should not start.
+        verify(mMockContextualSearchManager, never()).startContextualSearch(anyInt());
+        verifyNoMoreInteractions(mMockStatsLogManager);
+    }
+
+    @Test
+    public void invokeContextualSearchUncheckedWithHaptic_liveTile_failsToFinishRecentsAnimation() {
+        when(mMockContainerInterface.isInLiveTileMode()).thenReturn(true);
+        ArgumentCaptor<Runnable> switchToScreenshotCaptor = ArgumentCaptor.forClass(Runnable.class);
+        ArgumentCaptor<Runnable> finishRecentsAnimationCaptor =
+                ArgumentCaptor.forClass(Runnable.class);
+
+        assertTrue("Expected invocation unchecked to succeed",
+                mContextualSearchInvoker.invokeContextualSearchUncheckedWithHaptic(
+                        CONTEXTUAL_SEARCH_ENTRY_POINT));
+        verify(mMockRecentsView).switchToScreenshot(switchToScreenshotCaptor.capture());
+        switchToScreenshotCaptor.getValue().run();
+        verify(mMockRecentsView).finishRecentsAnimation(anyBoolean(), anyBoolean(),
+                finishRecentsAnimationCaptor.capture());
+        // Don't run finishRecentsAnimation's callback. Therefore ContextualSearch should not start.
+        verify(mMockContextualSearchManager, never()).startContextualSearch(anyInt());
+        verifyNoMoreInteractions(mMockStatsLogManager);
+    }
+
     private AutoCloseable overrideSearchHapticCommitFlag(boolean value) {
         return TestExtensions.overrideNavConfigFlag(
                 "ENABLE_SEARCH_HAPTIC_COMMIT",
diff --git a/quickstep/tests/src/com/android/quickstep/desktop/DesktopAppLaunchTransitionManagerTest.kt b/quickstep/tests/src/com/android/quickstep/desktop/DesktopAppLaunchTransitionManagerTest.kt
index 26189df..ae96c09c 100644
--- a/quickstep/tests/src/com/android/quickstep/desktop/DesktopAppLaunchTransitionManagerTest.kt
+++ b/quickstep/tests/src/com/android/quickstep/desktop/DesktopAppLaunchTransitionManagerTest.kt
@@ -30,6 +30,7 @@
 import com.android.dx.mockito.inline.extended.ExtendedMockito.mockitoSession
 import com.android.quickstep.SystemUiProxy
 import com.android.window.flags.Flags.FLAG_ENABLE_DESKTOP_APP_LAUNCH_TRANSITIONS
+import com.android.window.flags.Flags.FLAG_ENABLE_DESKTOP_APP_LAUNCH_TRANSITIONS_BUGFIX
 import com.android.wm.shell.shared.desktopmode.DesktopModeStatus
 import com.google.common.truth.Truth.assertThat
 import org.junit.After
@@ -74,7 +75,10 @@
     }
 
     @Test
-    @EnableFlags(FLAG_ENABLE_DESKTOP_APP_LAUNCH_TRANSITIONS)
+    @EnableFlags(
+        FLAG_ENABLE_DESKTOP_APP_LAUNCH_TRANSITIONS,
+        FLAG_ENABLE_DESKTOP_APP_LAUNCH_TRANSITIONS_BUGFIX,
+    )
     fun registerTransitions_appLaunchFlagEnabled_registersTransition() {
         transitionManager.registerTransitions()
 
@@ -82,7 +86,10 @@
     }
 
     @Test
-    @DisableFlags(FLAG_ENABLE_DESKTOP_APP_LAUNCH_TRANSITIONS)
+    @DisableFlags(
+        FLAG_ENABLE_DESKTOP_APP_LAUNCH_TRANSITIONS,
+        FLAG_ENABLE_DESKTOP_APP_LAUNCH_TRANSITIONS_BUGFIX,
+    )
     fun registerTransitions_appLaunchFlagDisabled_doesntRegisterTransition() {
         transitionManager.registerTransitions()
 
@@ -90,7 +97,10 @@
     }
 
     @Test
-    @EnableFlags(FLAG_ENABLE_DESKTOP_APP_LAUNCH_TRANSITIONS)
+    @EnableFlags(
+        FLAG_ENABLE_DESKTOP_APP_LAUNCH_TRANSITIONS,
+        FLAG_ENABLE_DESKTOP_APP_LAUNCH_TRANSITIONS_BUGFIX,
+    )
     fun registerTransitions_usesCorrectFilter() {
         transitionManager.registerTransitions()
         val filterArgumentCaptor = argumentCaptor<TransitionFilter>()
diff --git a/res/drawable/inset_rounded_action_button.xml b/res/drawable/inset_rounded_action_button.xml
new file mode 100644
index 0000000..8ae40c0
--- /dev/null
+++ b/res/drawable/inset_rounded_action_button.xml
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?><!--
+  ~ Copyright (C) 2024 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.
+  -->
+
+<inset xmlns:android="http://schemas.android.com/apk/res/android"
+    android:insetTop="@dimen/inset_rounded_action_button"
+    android:insetBottom="@dimen/inset_rounded_action_button"
+    android:insetLeft="@dimen/inset_rounded_action_button"
+    android:insetRight="@dimen/inset_rounded_action_button">
+    <shape
+        android:shape="rectangle">
+        <solid android:color="@color/materialColorSurfaceContainerLow" />
+        <corners android:radius="@dimen/rounded_button_radius" />
+        <stroke
+            android:width="1dp"
+            android:color="@color/materialColorSurfaceContainerLow" />
+    </shape>
+</inset>
diff --git a/res/layout/work_apps_edu.xml b/res/layout/work_apps_edu.xml
index a45d585..0e2c19a 100644
--- a/res/layout/work_apps_edu.xml
+++ b/res/layout/work_apps_edu.xml
@@ -25,9 +25,8 @@
         android:orientation="horizontal"
         android:background="@drawable/work_card"
         android:layout_gravity="center_horizontal"
-        android:paddingEnd="@dimen/work_card_margin"
         android:paddingStart="@dimen/work_card_margin"
-        android:paddingTop="@dimen/work_card_margin"
+        android:paddingEnd="@dimen/work_card_margin_end"
         android:paddingBottom="@dimen/work_card_margin"
         android:id="@+id/wrapper">
         <TextView
@@ -37,18 +36,22 @@
             android:layout_width="0dp"
             android:layout_height="wrap_content"
             android:layout_weight="1"
+            android:layout_marginTop="@dimen/work_card_margin"
             android:paddingEnd="@dimen/work_edu_card_text_end_margin"
             android:text="@string/work_profile_edu_work_apps"
             android:textDirection="locale"
             android:textSize="18sp" />
         <FrameLayout
+            android:id="@+id/action_btn"
             android:layout_width="@dimen/rounded_button_width"
             android:layout_height="@dimen/rounded_button_width"
-            android:background="@drawable/rounded_action_button">
+            android:layout_marginTop="@dimen/work_edu_card_button_margin_top"
+            android:gravity="center"
+            android:background="@drawable/inset_rounded_action_button">
             <ImageButton
-                android:id="@+id/action_btn"
                 android:layout_width="@dimen/x_icon_size"
                 android:layout_height="@dimen/x_icon_size"
+                android:clickable="false"
                 android:scaleType="centerInside"
                 android:layout_gravity="center"
                 android:contentDescription="@string/accessibility_close"
diff --git a/res/values-af/strings.xml b/res/values-af/strings.xml
index 93759f9..d28e1f5 100644
--- a/res/values-af/strings.xml
+++ b/res/values-af/strings.xml
@@ -21,9 +21,9 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="649227358658669779">"Launcher3"</string>
     <string name="work_folder_name" msgid="3753320833950115786">"Werk"</string>
-    <string name="activity_not_found" msgid="8071924732094499514">"Program is nie geïnstalleer nie."</string>
-    <string name="activity_not_available" msgid="7456344436509528827">"Program is nie beskikbaar nie"</string>
-    <string name="safemode_shortcut_error" msgid="9160126848219158407">"Afgelaaide program in veiligmodus gedeaktiveer"</string>
+    <string name="activity_not_found" msgid="8071924732094499514">"App is nie geïnstalleer nie."</string>
+    <string name="activity_not_available" msgid="7456344436509528827">"App is nie beskikbaar nie"</string>
+    <string name="safemode_shortcut_error" msgid="9160126848219158407">"Afgelaaide app in veiligmodus gedeaktiveer"</string>
     <string name="safemode_widget_error" msgid="4863470563535682004">"Legstukke gedeaktiveer in Veiligmodus"</string>
     <string name="shortcut_not_available" msgid="2536503539825726397">"Kortpad is nie beskikbaar nie"</string>
     <string name="home_screen" msgid="5629429142036709174">"Tuis"</string>
@@ -78,7 +78,7 @@
     <string name="all_apps_search_bar_hint" msgid="1390553134053255246">"Deursoek programme"</string>
     <string name="all_apps_loading_message" msgid="5813968043155271636">"Laai tans programme …"</string>
     <string name="all_apps_no_search_results" msgid="3200346862396363786">"Kon geen programme kry wat by \"<xliff:g id="QUERY">%1$s</xliff:g>\" pas nie"</string>
-    <string name="label_application" msgid="8531721983832654978">"Program"</string>
+    <string name="label_application" msgid="8531721983832654978">"App"</string>
     <string name="all_apps_label" msgid="5015784846527570951">"Alle apps"</string>
     <string name="notifications_header" msgid="1404149926117359025">"Kennisgewings"</string>
     <string name="long_press_shortcut_to_add" msgid="5405328730817637737">"Raak en hou om \'n kortpad te skuif."</string>
@@ -99,7 +99,7 @@
     <string name="pin_prediction" msgid="4196423321649756498">"Vasspeldvoorspelling"</string>
     <string name="bubble" msgid="3072951361014076670">"Borrel"</string>
     <string name="permlab_install_shortcut" msgid="5632423390354674437">"installeer kortpaaie"</string>
-    <string name="permdesc_install_shortcut" msgid="923466509822011139">"Laat \'n program toe om kortpaaie by te voeg sonder gebruikerinmenging."</string>
+    <string name="permdesc_install_shortcut" msgid="923466509822011139">"Laat \'n app toe om kortpaaie by te voeg sonder gebruikerinmenging."</string>
     <string name="permlab_read_settings" msgid="5136500343007704955">"lees tuis-instellings en -kortpaaie"</string>
     <string name="permdesc_read_settings" msgid="4208061150510996676">"Laat die program toe om die instellings en kortpaaie op tuisskerm te lees."</string>
     <string name="permlab_write_settings" msgid="4820028712156303762">"skryf tuis-instellings en -kortpaaie"</string>
@@ -143,8 +143,8 @@
     <string name="package_state_unknown" msgid="7592128424511031410">"Onbekend"</string>
     <string name="abandoned_clean_this" msgid="7610119707847920412">"Verwyder"</string>
     <string name="abandoned_search" msgid="891119232568284442">"Soek"</string>
-    <string name="abandoned_promises_title" msgid="7096178467971716750">"Hierdie program is nie geïnstalleer nie"</string>
-    <string name="abandoned_promise_explanation" msgid="3990027586878167529">"Die program vir hierdie ikoon is nie geïnstalleer nie. Jy kan dit verwyder of die program soek en dit self installeer."</string>
+    <string name="abandoned_promises_title" msgid="7096178467971716750">"Hierdie app is nie geïnstalleer nie"</string>
+    <string name="abandoned_promise_explanation" msgid="3990027586878167529">"Die app vir hierdie ikoon is nie geïnstalleer nie. Jy kan dit verwyder of die app soek en dit self installeer."</string>
     <string name="app_installing_title" msgid="5864044122733792085">"<xliff:g id="NAME">%1$s</xliff:g> installeer tans; <xliff:g id="PROGRESS">%2$s</xliff:g> voltooi"</string>
     <string name="app_downloading_title" msgid="8336702962104482644">"<xliff:g id="NAME">%1$s</xliff:g> laai tans af, <xliff:g id="PROGRESS">%2$s</xliff:g> voltooid"</string>
     <string name="app_waiting_download_title" msgid="7053938513995617849">"<xliff:g id="NAME">%1$s</xliff:g> wag tans om te installeer"</string>
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Verminder breedte"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Verminder hoogte"</string>
     <string name="widget_resized" msgid="9130327887929620">"Legstukgrootte is verander na breedte <xliff:g id="NUMBER_0">%1$s</xliff:g> hoogte <xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Kortpadkieslys"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Maak toe"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Maak toe"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Persoonlik"</string>
diff --git a/res/values-am/strings.xml b/res/values-am/strings.xml
index 5c130bc..6ed533e 100644
--- a/res/values-am/strings.xml
+++ b/res/values-am/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"ስፋት ይቀንሱ"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"ቁመት ይቀንሱ"</string>
     <string name="widget_resized" msgid="9130327887929620">"የመግብር መጠን ወደ ስፋት <xliff:g id="NUMBER_0">%1$s</xliff:g> ቁመት <xliff:g id="NUMBER_1">%2$s</xliff:g> ተለውጧል"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"የአቋራጭ ምናሌ"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"አሰናብት"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"ዝጋ"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"የግል"</string>
diff --git a/res/values-ar/strings.xml b/res/values-ar/strings.xml
index cc7ece1..e924f4d 100644
--- a/res/values-ar/strings.xml
+++ b/res/values-ar/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"تقليل العرض"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"تقليل الارتفاع"</string>
     <string name="widget_resized" msgid="9130327887929620">"تم تغيير حجم الأداة إلى العرض <xliff:g id="NUMBER_0">%1$s</xliff:g> والارتفاع <xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"قائمة الاختصارات"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"تجاهل"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"إغلاق"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"شخصية"</string>
diff --git a/res/values-as/strings.xml b/res/values-as/strings.xml
index 168d408..1e88444 100644
--- a/res/values-as/strings.xml
+++ b/res/values-as/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"প্ৰস্থ হ্ৰাস কৰক"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"উচ্চতা হ্ৰাস কৰক"</string>
     <string name="widget_resized" msgid="9130327887929620">"ৱিজেটৰ আকাৰ সলনি কৰি প্ৰস্থ <xliff:g id="NUMBER_0">%1$s</xliff:g> আৰু উচ্চতা <xliff:g id="NUMBER_1">%2$s</xliff:g> কৰা হ’ল"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"শ্বৰ্টকাটৰ মেনু"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"অগ্ৰাহ্য কৰক"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"বন্ধ কৰক"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"ব্যক্তিগত"</string>
@@ -200,7 +199,7 @@
     <string name="remote_action_failed" msgid="1383965239183576790">"বিফল: <xliff:g id="WHAT">%1$s</xliff:g>"</string>
     <string name="private_space_label" msgid="2359721649407947001">"প্ৰাইভেট স্পে\'চ"</string>
     <string name="private_space_secondary_label" msgid="9203933341714508907">"ছেট আপ কৰিবলৈ টিপক অথবা খোলক"</string>
-    <string name="ps_container_title" msgid="4391796149519594205">"ব্যক্তিগত"</string>
+    <string name="ps_container_title" msgid="4391796149519594205">"প্ৰাইভেট"</string>
     <string name="ps_container_settings" msgid="6059734123353320479">"ব্যক্তিগত স্পে’চৰ ছেটিং"</string>
     <string name="ps_container_unlock_button_content_description" msgid="9181551784092204234">"ব্যক্তিগত, আনলক কৰা আছে।"</string>
     <string name="ps_container_lock_button_content_description" msgid="5961993384382649530">"ব্যক্তিগত, লক কৰা আছে।"</string>
diff --git a/res/values-az/strings.xml b/res/values-az/strings.xml
index 9f2a435..516b401 100644
--- a/res/values-az/strings.xml
+++ b/res/values-az/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Eni azaldın"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Hündürlüyü azaldın"</string>
     <string name="widget_resized" msgid="9130327887929620">"Vidcetin eni <xliff:g id="NUMBER_0">%1$s</xliff:g> hündürlüyü <xliff:g id="NUMBER_1">%2$s</xliff:g> kimi ölçüləndirildi"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Qısayol menyusu"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Rədd edin"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Bağlayın"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Şəxsi"</string>
@@ -200,7 +199,7 @@
     <string name="remote_action_failed" msgid="1383965239183576790">"Alınmadı: <xliff:g id="WHAT">%1$s</xliff:g>"</string>
     <string name="private_space_label" msgid="2359721649407947001">"Məxfi sahə"</string>
     <string name="private_space_secondary_label" msgid="9203933341714508907">"Toxunaraq ayarlayın və ya açın"</string>
-    <string name="ps_container_title" msgid="4391796149519594205">"Şəxsi"</string>
+    <string name="ps_container_title" msgid="4391796149519594205">"Məxfi"</string>
     <string name="ps_container_settings" msgid="6059734123353320479">"Şəxsi məkan ayarları"</string>
     <string name="ps_container_unlock_button_content_description" msgid="9181551784092204234">"Şəxsi, kilidli deyil."</string>
     <string name="ps_container_lock_button_content_description" msgid="5961993384382649530">"Şəxsi, kilidli."</string>
diff --git a/res/values-b+sr+Latn/strings.xml b/res/values-b+sr+Latn/strings.xml
index 1cea1fc..c8aaa88 100644
--- a/res/values-b+sr+Latn/strings.xml
+++ b/res/values-b+sr+Latn/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Smanji širinu"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Smanji visinu"</string>
     <string name="widget_resized" msgid="9130327887929620">"Veličina vidžeta je promenjena na širinu <xliff:g id="NUMBER_0">%1$s</xliff:g> i visinu <xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Meni sa prečicama"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Odbaci"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Zatvori"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Lično"</string>
diff --git a/res/values-be/strings.xml b/res/values-be/strings.xml
index 74f988d..b2f2f32 100644
--- a/res/values-be/strings.xml
+++ b/res/values-be/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Паменшыць шырыню"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Паменшыць вышыню"</string>
     <string name="widget_resized" msgid="9130327887929620">"Памеры віджэта зменены на: шырыня <xliff:g id="NUMBER_0">%1$s</xliff:g>, вышыня <xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Меню спалучэнняў клавіш"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Адхіліць"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Закрыць"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Асабістыя"</string>
diff --git a/res/values-bg/strings.xml b/res/values-bg/strings.xml
index 7799a3b..f4fb396 100644
--- a/res/values-bg/strings.xml
+++ b/res/values-bg/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Намаляване на ширината"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Намаляване на височината"</string>
     <string name="widget_resized" msgid="9130327887929620">"Приспособлението е преоразмерено към ширина <xliff:g id="NUMBER_0">%1$s</xliff:g> и височина <xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Меню за клавишните комбинации"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Отхвърляне"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Затваряне"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Лични"</string>
@@ -200,7 +199,7 @@
     <string name="remote_action_failed" msgid="1383965239183576790">"Неуспешно: <xliff:g id="WHAT">%1$s</xliff:g>"</string>
     <string name="private_space_label" msgid="2359721649407947001">"Частно пространство"</string>
     <string name="private_space_secondary_label" msgid="9203933341714508907">"Докоснете за настройване или отваряне"</string>
-    <string name="ps_container_title" msgid="4391796149519594205">"Лично"</string>
+    <string name="ps_container_title" msgid="4391796149519594205">"Частно"</string>
     <string name="ps_container_settings" msgid="6059734123353320479">"Настройки за частното пространство"</string>
     <string name="ps_container_unlock_button_content_description" msgid="9181551784092204234">"Частно, отключено."</string>
     <string name="ps_container_lock_button_content_description" msgid="5961993384382649530">"Частно, заключено."</string>
diff --git a/res/values-bn/strings.xml b/res/values-bn/strings.xml
index 88f92c3..1d38e66 100644
--- a/res/values-bn/strings.xml
+++ b/res/values-bn/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"প্রস্থ কমান"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"উচ্চতা কমান"</string>
     <string name="widget_resized" msgid="9130327887929620">"উইজেটের আকার প্রস্থ <xliff:g id="NUMBER_0">%1$s</xliff:g> উচ্চতা <xliff:g id="NUMBER_1">%2$s</xliff:g> তে পরিবর্তন করা হয়েছে"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"শর্টকাট মেনু"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"খারিজ করুন"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"বন্ধ করুন"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"ব্যক্তিগত"</string>
@@ -200,7 +199,7 @@
     <string name="remote_action_failed" msgid="1383965239183576790">"কাজটি করা যায়নি: <xliff:g id="WHAT">%1$s</xliff:g>"</string>
     <string name="private_space_label" msgid="2359721649407947001">"ব্যক্তিগত স্পেস"</string>
     <string name="private_space_secondary_label" msgid="9203933341714508907">"সেট-আপ করতে বা খুলতে ট্যাপ করুন"</string>
-    <string name="ps_container_title" msgid="4391796149519594205">"ব্যক্তিগত"</string>
+    <string name="ps_container_title" msgid="4391796149519594205">"প্রাইভেট"</string>
     <string name="ps_container_settings" msgid="6059734123353320479">"ব্যক্তিগত স্পেসের সেটিংস"</string>
     <string name="ps_container_unlock_button_content_description" msgid="9181551784092204234">"ব্যক্তিগত, আনলক করা আছে।"</string>
     <string name="ps_container_lock_button_content_description" msgid="5961993384382649530">"ব্যক্তিগত, লক করা আছে।"</string>
diff --git a/res/values-bs/strings.xml b/res/values-bs/strings.xml
index 64ff0b6..57b475c 100644
--- a/res/values-bs/strings.xml
+++ b/res/values-bs/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Smanji širinu"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Smanji visinu"</string>
     <string name="widget_resized" msgid="9130327887929620">"Veličina vidžeta je promijenjena na širinu <xliff:g id="NUMBER_0">%1$s</xliff:g> visinu <xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Meni prečica"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Odbaci"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Zatvaranje"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Lično"</string>
diff --git a/res/values-ca/strings.xml b/res/values-ca/strings.xml
index 185788b..5c7409f 100644
--- a/res/values-ca/strings.xml
+++ b/res/values-ca/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Redueix l\'amplada"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Redueix l\'alçada"</string>
     <string name="widget_resized" msgid="9130327887929620">"S\'ha canviat la mida del widget a l\'amplada <xliff:g id="NUMBER_0">%1$s</xliff:g> i l\'alçada <xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Menú de dreceres"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Ignora"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Tanca"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Personal"</string>
diff --git a/res/values-cs/strings.xml b/res/values-cs/strings.xml
index 3caba23..e5f26da 100644
--- a/res/values-cs/strings.xml
+++ b/res/values-cs/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Snížit šířku"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Snížit výšku"</string>
     <string name="widget_resized" msgid="9130327887929620">"Velikost widgetu upravena: šířka <xliff:g id="NUMBER_0">%1$s</xliff:g>, výška <xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Nabídka zkratek"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Zavřít"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Zavřít"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Osobní"</string>
diff --git a/res/values-da/strings.xml b/res/values-da/strings.xml
index 07595e8..1fb015f 100644
--- a/res/values-da/strings.xml
+++ b/res/values-da/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Reducer bredden"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Reducer højden"</string>
     <string name="widget_resized" msgid="9130327887929620">"Størrelsen for widgetten er ændret til bredde <xliff:g id="NUMBER_0">%1$s</xliff:g> og højde <xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Genvejsmenu"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Afvis"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Luk"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Personlig"</string>
diff --git a/res/values-de/strings.xml b/res/values-de/strings.xml
index a9a1aa0..6eb50a7 100644
--- a/res/values-de/strings.xml
+++ b/res/values-de/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Breite verringern"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Höhe verringern"</string>
     <string name="widget_resized" msgid="9130327887929620">"Größe des Widgets zu Breite <xliff:g id="NUMBER_0">%1$s</xliff:g> und Höhe <xliff:g id="NUMBER_1">%2$s</xliff:g> geändert"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Menü für Tastenkombinationen"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Schließen"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Schließen"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Privat"</string>
diff --git a/res/values-el/strings.xml b/res/values-el/strings.xml
index 17ddee3..deaf4ff 100644
--- a/res/values-el/strings.xml
+++ b/res/values-el/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"μείωση του πλάτους"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Μείωση του ύψους"</string>
     <string name="widget_resized" msgid="9130327887929620">"Έγινε προσαρμογή του μεγέθους του γραφικού στοιχείου σε <xliff:g id="NUMBER_0">%1$s</xliff:g> πλάτος και <xliff:g id="NUMBER_1">%2$s</xliff:g> ύψος"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Μενού συντομεύσεων"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Παράβλεψη"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Κλείσιμο"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Προσωπικές"</string>
diff --git a/res/values-en-rAU/strings.xml b/res/values-en-rAU/strings.xml
index faffd89..1175601 100644
--- a/res/values-en-rAU/strings.xml
+++ b/res/values-en-rAU/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Decrease width"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Decrease height"</string>
     <string name="widget_resized" msgid="9130327887929620">"Widget re-sized to width <xliff:g id="NUMBER_0">%1$s</xliff:g> height <xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Shortcut menu"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Dismiss"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Close"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Personal"</string>
diff --git a/res/values-en-rGB/strings.xml b/res/values-en-rGB/strings.xml
index faffd89..1175601 100644
--- a/res/values-en-rGB/strings.xml
+++ b/res/values-en-rGB/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Decrease width"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Decrease height"</string>
     <string name="widget_resized" msgid="9130327887929620">"Widget re-sized to width <xliff:g id="NUMBER_0">%1$s</xliff:g> height <xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Shortcut menu"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Dismiss"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Close"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Personal"</string>
diff --git a/res/values-en-rIN/strings.xml b/res/values-en-rIN/strings.xml
index faffd89..1175601 100644
--- a/res/values-en-rIN/strings.xml
+++ b/res/values-en-rIN/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Decrease width"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Decrease height"</string>
     <string name="widget_resized" msgid="9130327887929620">"Widget re-sized to width <xliff:g id="NUMBER_0">%1$s</xliff:g> height <xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Shortcut menu"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Dismiss"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Close"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Personal"</string>
diff --git a/res/values-es-rUS/strings.xml b/res/values-es-rUS/strings.xml
index d08eb53..7006bfb 100644
--- a/res/values-es-rUS/strings.xml
+++ b/res/values-es-rUS/strings.xml
@@ -32,8 +32,7 @@
     <string name="split_app_info_accessibility" msgid="5475288491241414932">"Información de la app de %1$s"</string>
     <string name="split_app_usage_settings" msgid="7214375263347964093">"Configuración del uso de %1$s"</string>
     <string name="new_window_option_taskbar" msgid="6448780542727767211">"Ventana nueva"</string>
-    <!-- no translation found for manage_windows_option_taskbar (2294109489960654212) -->
-    <skip />
+    <string name="manage_windows_option_taskbar" msgid="2294109489960654212">"Administrar ventanas"</string>
     <string name="save_app_pair" msgid="5647523853662686243">"Guardar vinculación"</string>
     <string name="app_pair_default_title" msgid="4045241727446873529">"<xliff:g id="APP1">%1$s</xliff:g> | <xliff:g id="APP2">%2$s</xliff:g>"</string>
     <string name="app_pair_unlaunchable_at_screen_size" msgid="3446551575502685376">"No se admite esta vinculación de apps en este dispositivo"</string>
@@ -179,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Reducir el ancho"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Reducir la altura"</string>
     <string name="widget_resized" msgid="9130327887929620">"Se cambió la dimensión del widget a <xliff:g id="NUMBER_0">%1$s</xliff:g> de ancho y <xliff:g id="NUMBER_1">%2$s</xliff:g> de alto."</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Menú de accesos directos"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Descartar"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Cerrar"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Personal"</string>
diff --git a/res/values-es/strings.xml b/res/values-es/strings.xml
index 1a71a0e..dabba16 100644
--- a/res/values-es/strings.xml
+++ b/res/values-es/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Reducir ancho"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Reducir altura"</string>
     <string name="widget_resized" msgid="9130327887929620">"Se ha modificado el tamaño del widget a <xliff:g id="NUMBER_0">%1$s</xliff:g> de ancho y <xliff:g id="NUMBER_1">%2$s</xliff:g> de alto"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Menú de combinaciones de teclas"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Cerrar"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Cerrar"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Personal"</string>
diff --git a/res/values-et/strings.xml b/res/values-et/strings.xml
index 70d2f8b..72f6bb8 100644
--- a/res/values-et/strings.xml
+++ b/res/values-et/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Vähenda laiust"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Vähenda kõrgust"</string>
     <string name="widget_resized" msgid="9130327887929620">"Vidina suurust muudeti. Laius: <xliff:g id="NUMBER_0">%1$s</xliff:g>. Kõrgus: <xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Kiirmenüü"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Loobu"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Sule"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Isiklik"</string>
diff --git a/res/values-eu/strings.xml b/res/values-eu/strings.xml
index ec63b18..37d3e4f 100644
--- a/res/values-eu/strings.xml
+++ b/res/values-eu/strings.xml
@@ -91,7 +91,7 @@
     <string name="all_apps_button_work_label" msgid="7270707118948892488">"Laneko aplikazioen zerrenda"</string>
     <string name="remove_drop_target_label" msgid="7812859488053230776">"Kendu"</string>
     <string name="uninstall_drop_target_label" msgid="4722034217958379417">"Desinstalatu"</string>
-    <string name="app_info_drop_target_label" msgid="692894985365717661">"Aplikazioaren informazioa"</string>
+    <string name="app_info_drop_target_label" msgid="692894985365717661">"Aplik. buruzko info."</string>
     <string name="install_private_system_shortcut_label" msgid="1616889277073184841">"Instalatu pribatuan"</string>
     <string name="uninstall_private_system_shortcut_label" msgid="8423460530441627982">"Desinstalatu aplikazioa"</string>
     <string name="install_drop_target_label" msgid="2539096853673231757">"Instalatu"</string>
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Txikitu zabalera"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Txikitu altuera"</string>
     <string name="widget_resized" msgid="9130327887929620">"Aldatu da widgetaren tamaina. Zabalera: <xliff:g id="NUMBER_0">%1$s</xliff:g>. Altuera: <xliff:g id="NUMBER_1">%2$s</xliff:g>."</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Lasterbideen menua"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Baztertu"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Itxi"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Pertsonalak"</string>
diff --git a/res/values-fa/strings.xml b/res/values-fa/strings.xml
index 5930f22..11130e4 100644
--- a/res/values-fa/strings.xml
+++ b/res/values-fa/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"کاهش عرض"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"کاهش ارتفاع"</string>
     <string name="widget_resized" msgid="9130327887929620">"اندازه ابزاره به عرض <xliff:g id="NUMBER_0">%1$s</xliff:g> ارتفاع <xliff:g id="NUMBER_1">%2$s</xliff:g> تغییر کرد"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"منو میان‌بر"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"رد کردن"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"بستن"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"شخصی"</string>
diff --git a/res/values-fi/strings.xml b/res/values-fi/strings.xml
index 0e2eb3f..3a25c51 100644
--- a/res/values-fi/strings.xml
+++ b/res/values-fi/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Vähennä leveyttä"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Vähennä korkeutta"</string>
     <string name="widget_resized" msgid="9130327887929620">"Widgetin kokoa muutettiin. Sen leveys on nyt <xliff:g id="NUMBER_0">%1$s</xliff:g> ja korkeus <xliff:g id="NUMBER_1">%2$s</xliff:g>."</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Pikanäppäinvalikko"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Hylkää"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Sulje"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Henkilökohtaiset"</string>
diff --git a/res/values-fr-rCA/strings.xml b/res/values-fr-rCA/strings.xml
index 93bdcb5..45a0403 100644
--- a/res/values-fr-rCA/strings.xml
+++ b/res/values-fr-rCA/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Diminuer la largeur"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Diminuer la hauteur"</string>
     <string name="widget_resized" msgid="9130327887929620">"Le widget a été redimensionné (largeur : <xliff:g id="NUMBER_0">%1$s</xliff:g>, hauteur : <xliff:g id="NUMBER_1">%2$s</xliff:g>)"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Menu des raccourcis"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Ignorer"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Fermer"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Personnel"</string>
diff --git a/res/values-fr/strings.xml b/res/values-fr/strings.xml
index 5db4437..0a61189 100644
--- a/res/values-fr/strings.xml
+++ b/res/values-fr/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Diminuer la largeur"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Diminuer la hauteur"</string>
     <string name="widget_resized" msgid="9130327887929620">"Le widget a bien été redimensionné (largeur : <xliff:g id="NUMBER_0">%1$s</xliff:g>, hauteur : <xliff:g id="NUMBER_1">%2$s</xliff:g>)."</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Menu de raccourci"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Ignorer"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Fermer"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Personnel"</string>
diff --git a/res/values-gl/strings.xml b/res/values-gl/strings.xml
index 72fdd1b..293a6b3 100644
--- a/res/values-gl/strings.xml
+++ b/res/values-gl/strings.xml
@@ -137,7 +137,7 @@
     <string name="msg_missing_notification_access" msgid="281113995110910548">"Para que se mostren os puntos de notificacións, activa as notificacións da aplicación <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="title_change_settings" msgid="1376365968844349552">"Cambiar configuración"</string>
     <string name="notification_dots_service_title" msgid="4284221181793592871">"Mostra puntos de notificacións"</string>
-    <string name="developer_options_title" msgid="700788437593726194">"Opcións de programador"</string>
+    <string name="developer_options_title" msgid="700788437593726194">"Opcións de programación"</string>
     <string name="auto_add_shortcuts_label" msgid="4926805029653694105">"Engadir iconas de aplicacións á pantalla de inicio"</string>
     <string name="auto_add_shortcuts_description" msgid="7117251166066978730">"Para novas aplicacións"</string>
     <string name="package_state_unknown" msgid="7592128424511031410">"Descoñecido"</string>
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Reducir ancho"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Reducir altura"</string>
     <string name="widget_resized" msgid="9130327887929620">"Cambiouse o tamaño do widget polo ancho <xliff:g id="NUMBER_0">%1$s</xliff:g> e a altura <xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Menú do atallo"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Pechar"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Pechar"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Persoal"</string>
diff --git a/res/values-gu/strings.xml b/res/values-gu/strings.xml
index 58cbac8..c7d3a10 100644
--- a/res/values-gu/strings.xml
+++ b/res/values-gu/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"પહોળાઈ ઘટાડો"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"ઊંચાઈ ઘટાડો"</string>
     <string name="widget_resized" msgid="9130327887929620">"વિજેટનો આકાર બદલીને <xliff:g id="NUMBER_0">%1$s</xliff:g> પહોળાઈ <xliff:g id="NUMBER_1">%2$s</xliff:g> ઊંચાઈ કર્યો"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"શૉર્ટકટ મેનૂ"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"છોડી દો"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"બંધ કરો"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"વ્યક્તિગત ઍપ"</string>
diff --git a/res/values-hi/strings.xml b/res/values-hi/strings.xml
index e56e620..1bf63d6 100644
--- a/res/values-hi/strings.xml
+++ b/res/values-hi/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"चौड़ाई घटाएं"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"ऊंचाई घटाएं"</string>
     <string name="widget_resized" msgid="9130327887929620">"विजेट का आकार बदलकर उसकी चौड़ाई <xliff:g id="NUMBER_0">%1$s</xliff:g> और ऊंचाई <xliff:g id="NUMBER_1">%2$s</xliff:g> कर दी गई"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"शॉर्टकट मेन्यू"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"खारिज करें"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"बंद करें"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"निजी ऐप्लिकेशन"</string>
@@ -200,7 +199,7 @@
     <string name="remote_action_failed" msgid="1383965239183576790">"पूरा नहीं हुआ: <xliff:g id="WHAT">%1$s</xliff:g>"</string>
     <string name="private_space_label" msgid="2359721649407947001">"प्राइवेट स्पेस"</string>
     <string name="private_space_secondary_label" msgid="9203933341714508907">"सेट अप करने या खोलने के लिए टैप करें"</string>
-    <string name="ps_container_title" msgid="4391796149519594205">"निजी"</string>
+    <string name="ps_container_title" msgid="4391796149519594205">"प्राइवेट"</string>
     <string name="ps_container_settings" msgid="6059734123353320479">"प्राइवेट स्पेस सेटिंग"</string>
     <string name="ps_container_unlock_button_content_description" msgid="9181551784092204234">"प्राइवेट स्पेस को अनलॉक किया गया."</string>
     <string name="ps_container_lock_button_content_description" msgid="5961993384382649530">"प्राइवेट स्पेस को लॉक किया गया."</string>
diff --git a/res/values-hr/strings.xml b/res/values-hr/strings.xml
index 8f0008f..7bf6f33 100644
--- a/res/values-hr/strings.xml
+++ b/res/values-hr/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Smanjenje širine"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Smanjenje visine"</string>
     <string name="widget_resized" msgid="9130327887929620">"Širina widgeta promijenjena je na <xliff:g id="NUMBER_0">%1$s</xliff:g>, a visina na <xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Izbornik prečaca"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Odbaci"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Zatvori"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Osobno"</string>
diff --git a/res/values-hu/strings.xml b/res/values-hu/strings.xml
index 91761d0..e82566e 100644
--- a/res/values-hu/strings.xml
+++ b/res/values-hu/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Szélesség csökkentése"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Magasság csökkentése"</string>
     <string name="widget_resized" msgid="9130327887929620">"Modul átméretezve <xliff:g id="NUMBER_0">%1$s</xliff:g> szélességre és <xliff:g id="NUMBER_1">%2$s</xliff:g> magasságra"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Gyorsparancsok menüje"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Elvetés"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Bezárás"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Személyes"</string>
diff --git a/res/values-hy/strings.xml b/res/values-hy/strings.xml
index 91f9bca..4879d4d 100644
--- a/res/values-hy/strings.xml
+++ b/res/values-hy/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Նվազեցնել լայնությունը"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Նվազեցնել բարձրությունը"</string>
     <string name="widget_resized" msgid="9130327887929620">"Վիջեթի լայնությունը փոխվել է <xliff:g id="NUMBER_0">%1$s</xliff:g>-ի, իսկ բարձրությունը՝ <xliff:g id="NUMBER_1">%2$s</xliff:g>-ի"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Դյուրանցման ընտրացանկ"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Անտեսել"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Փակել"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Անձնական"</string>
diff --git a/res/values-in/strings.xml b/res/values-in/strings.xml
index 69a52f7..dde261a 100644
--- a/res/values-in/strings.xml
+++ b/res/values-in/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Kurangi lebar"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Kurangi tinggi"</string>
     <string name="widget_resized" msgid="9130327887929620">"Widget diubah ukurannya menjadi lebar <xliff:g id="NUMBER_0">%1$s</xliff:g> tinggi <xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Menu Pintasan"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Tutup"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Tutup"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Pribadi"</string>
diff --git a/res/values-is/strings.xml b/res/values-is/strings.xml
index 604e760..0698bab 100644
--- a/res/values-is/strings.xml
+++ b/res/values-is/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Minnka breidd"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Minnka hæð"</string>
     <string name="widget_resized" msgid="9130327887929620">"Stærð græju breytt í <xliff:g id="NUMBER_0">%1$s</xliff:g> á breidd og <xliff:g id="NUMBER_1">%2$s</xliff:g> á hæð"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Flýtileiðavalmynd"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Hunsa"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Loka"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Persónulegt"</string>
@@ -200,7 +199,7 @@
     <string name="remote_action_failed" msgid="1383965239183576790">"Mistókst: <xliff:g id="WHAT">%1$s</xliff:g>"</string>
     <string name="private_space_label" msgid="2359721649407947001">"Leynirými"</string>
     <string name="private_space_secondary_label" msgid="9203933341714508907">"Ýttu til að setja upp eða opna"</string>
-    <string name="ps_container_title" msgid="4391796149519594205">"Lokað"</string>
+    <string name="ps_container_title" msgid="4391796149519594205">"Leynilegt"</string>
     <string name="ps_container_settings" msgid="6059734123353320479">"Stillingar einkarýmis"</string>
     <string name="ps_container_unlock_button_content_description" msgid="9181551784092204234">"Lokað, ólæst."</string>
     <string name="ps_container_lock_button_content_description" msgid="5961993384382649530">"Lokað, læst."</string>
diff --git a/res/values-it/strings.xml b/res/values-it/strings.xml
index 66c4ddd..fdd62a4 100644
--- a/res/values-it/strings.xml
+++ b/res/values-it/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Riduci larghezza"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Riduci altezza"</string>
     <string name="widget_resized" msgid="9130327887929620">"Widget ridimensionato a larghezza <xliff:g id="NUMBER_0">%1$s</xliff:g>, altezza <xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Menu scorciatoie"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Ignora"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Esci"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Personali"</string>
diff --git a/res/values-iw/strings.xml b/res/values-iw/strings.xml
index e5fb2a8..cfc0291 100644
--- a/res/values-iw/strings.xml
+++ b/res/values-iw/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"הקטנת רוחב"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"הקטנת גובה"</string>
     <string name="widget_resized" msgid="9130327887929620">"גודל הווידג\'ט שונה - רוחב <xliff:g id="NUMBER_0">%1$s</xliff:g> גובה <xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"תפריט קיצורי הדרך"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"סגירה"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"סגירה"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"אישי"</string>
diff --git a/res/values-ja/strings.xml b/res/values-ja/strings.xml
index 1a9fff1..01626ab 100644
--- a/res/values-ja/strings.xml
+++ b/res/values-ja/strings.xml
@@ -46,7 +46,7 @@
     <string name="widget_accessible_dims_format" msgid="3640149169885301790">"幅 %1$d、高さ %2$d"</string>
     <string name="widget_preview_context_description" msgid="9045841361655787574">"<xliff:g id="WIDGET_NAME">%1$s</xliff:g> ウィジェット"</string>
     <string name="widget_preview_name_and_dims_content_description" msgid="8489038126122831595">"<xliff:g id="WIDGET_NAME">%1$s</xliff:g>ウィジェット、幅%2$d、高さ%3$d"</string>
-    <string name="add_item_request_drag_hint" msgid="8730547755622776606">"ウィジェットを押し続けると、ホーム画面上に移動できます"</string>
+    <string name="add_item_request_drag_hint" msgid="8730547755622776606">"ウィジェットを長押しすると、ホーム画面上の任意の場所に移動できます"</string>
     <string name="add_to_home_screen" msgid="9168649446635919791">"ホーム画面に追加"</string>
     <string name="added_to_home_screen_accessibility_text" msgid="4451545765448884415">"「<xliff:g id="WIDGET_NAME">%1$s</xliff:g>」ウィジェットをホーム画面に追加しました"</string>
     <string name="suggested_widgets_header_title" msgid="1844314680798145222">"候補"</string>
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"幅を狭くする"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"高さを低くする"</string>
     <string name="widget_resized" msgid="9130327887929620">"ウィジェットのサイズを幅<xliff:g id="NUMBER_0">%1$s</xliff:g>、高さ<xliff:g id="NUMBER_1">%2$s</xliff:g>に変更しました"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"ショートカット メニュー"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"表示しない"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"閉じる"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"個人用"</string>
diff --git a/res/values-ka/strings.xml b/res/values-ka/strings.xml
index 2c8d484..536c1ad 100644
--- a/res/values-ka/strings.xml
+++ b/res/values-ka/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"სიგანის შემცირება"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"სიმაღლის შემცირება"</string>
     <string name="widget_resized" msgid="9130327887929620">"ვიჯეტის ზომები შეიცვალა: სიგანე <xliff:g id="NUMBER_0">%1$s</xliff:g> სიმაღლე <xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"მალსახმობის მენიუ"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"დახურვა"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"დახურვა"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"პირადი"</string>
diff --git a/res/values-kk/strings.xml b/res/values-kk/strings.xml
index f3035c5..b7f38b9 100644
--- a/res/values-kk/strings.xml
+++ b/res/values-kk/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Енін азайту"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Биіктігін азайту"</string>
     <string name="widget_resized" msgid="9130327887929620">"Виджет өлшемінің ені <xliff:g id="NUMBER_0">%1$s</xliff:g>, биіктігі <xliff:g id="NUMBER_1">%2$s</xliff:g> болып өзгертілді"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Жылдам пәрмен мәзірі"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Бас тарту"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Жабу"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Жеке"</string>
@@ -200,7 +199,7 @@
     <string name="remote_action_failed" msgid="1383965239183576790">"Қате шықты: <xliff:g id="WHAT">%1$s</xliff:g>"</string>
     <string name="private_space_label" msgid="2359721649407947001">"Құпия кеңістік"</string>
     <string name="private_space_secondary_label" msgid="9203933341714508907">"Реттеу немесе ашу үшін түртіңіз"</string>
-    <string name="ps_container_title" msgid="4391796149519594205">"Жеке"</string>
+    <string name="ps_container_title" msgid="4391796149519594205">"Құпия"</string>
     <string name="ps_container_settings" msgid="6059734123353320479">"Құпия кеңістік параметрлері"</string>
     <string name="ps_container_unlock_button_content_description" msgid="9181551784092204234">"Құпия (құлыпталмаған)."</string>
     <string name="ps_container_lock_button_content_description" msgid="5961993384382649530">"Құпия (құлыптаулы)."</string>
diff --git a/res/values-km/strings.xml b/res/values-km/strings.xml
index 7566781..6a707ae 100644
--- a/res/values-km/strings.xml
+++ b/res/values-km/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"បន្ថយទទឹង"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"បន្ថយកម្ពស់"</string>
     <string name="widget_resized" msgid="9130327887929620">"ធាតុក្រាហ្វិកដែលបានប្តូរទំហំទៅទទឹងប្រវែង <xliff:g id="NUMBER_0">%1$s</xliff:g> កម្ពស់ប្រវែង <xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"ម៉ឺនុយផ្លូវ​កាត់"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"ច្រានចោល"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"បិទ"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"ផ្ទាល់ខ្លួន"</string>
diff --git a/res/values-kn/strings.xml b/res/values-kn/strings.xml
index d4682c4..0ce1a0f 100644
--- a/res/values-kn/strings.xml
+++ b/res/values-kn/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"ಅಗಲವನ್ನು ಕಡಿಮೆ ಮಾಡಿ"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"ಎತ್ತರವನ್ನು ಕಡಿಮೆ ಮಾಡಿ"</string>
     <string name="widget_resized" msgid="9130327887929620">"ವಿಜೆಟ್ ಅನ್ನು <xliff:g id="NUMBER_0">%1$s</xliff:g> ಅಗಲ <xliff:g id="NUMBER_1">%2$s</xliff:g> ಎತ್ತರಕ್ಕೆ ಮರುಗಾತ್ರಗೊಳಿಸಲಾಗಿದೆ"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"ಶಾರ್ಟ್‌ಕಟ್ ಮೆನು"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"ವಜಾಗೊಳಿಸಿ"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"ಮುಚ್ಚಿರಿ"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"ವೈಯಕ್ತಿಕ"</string>
@@ -200,7 +199,7 @@
     <string name="remote_action_failed" msgid="1383965239183576790">"ವಿಫಲವಾಗಿದೆ: <xliff:g id="WHAT">%1$s</xliff:g>"</string>
     <string name="private_space_label" msgid="2359721649407947001">"ಖಾಸಗಿ ಸ್ಪೇಸ್"</string>
     <string name="private_space_secondary_label" msgid="9203933341714508907">"ಸೆಟಪ್ ಮಾಡಲು ಅಥವಾ ತೆರೆಯಲು ಟ್ಯಾಪ್ ಮಾಡಿ"</string>
-    <string name="ps_container_title" msgid="4391796149519594205">"ಖಾಸಗಿ"</string>
+    <string name="ps_container_title" msgid="4391796149519594205">"ಪ್ರೈವೆಟ್"</string>
     <string name="ps_container_settings" msgid="6059734123353320479">"ಖಾಸಗಿ ಸ್ಪೇಸ್ ಸೆಟ್ಟಿಂಗ್‌ಗಳು"</string>
     <string name="ps_container_unlock_button_content_description" msgid="9181551784092204234">"ಖಾಸಗಿ, ಅನ್‌ಲಾಕ್ ಮಾಡಲಾಗಿದೆ."</string>
     <string name="ps_container_lock_button_content_description" msgid="5961993384382649530">"ಖಾಸಗಿ, ಲಾಕ್ ಮಾಡಲಾಗಿದೆ."</string>
diff --git a/res/values-ko/strings.xml b/res/values-ko/strings.xml
index 13aaaa2..19e75d1 100644
--- a/res/values-ko/strings.xml
+++ b/res/values-ko/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"폭 줄이기"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"높이 줄이기"</string>
     <string name="widget_resized" msgid="9130327887929620">"폭 <xliff:g id="NUMBER_0">%1$s</xliff:g>, 높이 <xliff:g id="NUMBER_1">%2$s</xliff:g>로 위젯 크기 조정됨"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"바로가기 메뉴"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"닫기"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"닫기"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"개인"</string>
diff --git a/res/values-ky/strings.xml b/res/values-ky/strings.xml
index d41ffe8..901b2bd 100644
--- a/res/values-ky/strings.xml
+++ b/res/values-ky/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Ичкертүү"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Жапыздатуу"</string>
     <string name="widget_resized" msgid="9130327887929620">"Виджеттин кеңдиги <xliff:g id="NUMBER_0">%1$s</xliff:g> бийиктиги <xliff:g id="NUMBER_1">%2$s</xliff:g> болду"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Ыкчам баскычтын менюсу"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Этибарга албоо"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Жабуу"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Жеке колдонмолор"</string>
diff --git a/res/values-lo/strings.xml b/res/values-lo/strings.xml
index ace3225..f01dc67 100644
--- a/res/values-lo/strings.xml
+++ b/res/values-lo/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"ຫຼຸດ​ລວງ​ກ້​ວາງ​ລົງ"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"ຫຼຸດ​ລວງ​ສູງ​ລົງ"</string>
     <string name="widget_resized" msgid="9130327887929620">"ປ່ຽນ​ຂະ​ໜາດ​ວິດ​ເຈັດ​ເປັນ​ລວງ​ກ້​ວາງ <xliff:g id="NUMBER_0">%1$s</xliff:g> ລວງ​ສູງ <xliff:g id="NUMBER_1">%2$s</xliff:g> ແລ້ວ"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"ເມນູທາງລັດ"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"ປິດໄວ້"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"ປິດ"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"ສ່ວນຕົວ"</string>
diff --git a/res/values-lt/strings.xml b/res/values-lt/strings.xml
index b298d8e..f5e21de 100644
--- a/res/values-lt/strings.xml
+++ b/res/values-lt/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Sumažinti plotį"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Sumažinti aukštį"</string>
     <string name="widget_resized" msgid="9130327887929620">"Valdiklio dydis pakeistas: plotis – <xliff:g id="NUMBER_0">%1$s</xliff:g>, aukštis – <xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Sparčiųjų klavišų meniu"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Atsisakyti"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Uždaryti"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Asmeninės"</string>
@@ -200,7 +199,7 @@
     <string name="remote_action_failed" msgid="1383965239183576790">"Nepavyko: <xliff:g id="WHAT">%1$s</xliff:g>"</string>
     <string name="private_space_label" msgid="2359721649407947001">"Privati erdvė"</string>
     <string name="private_space_secondary_label" msgid="9203933341714508907">"Palieskite, kad nustatytumėte arba atidarytumėte"</string>
-    <string name="ps_container_title" msgid="4391796149519594205">"Privatus"</string>
+    <string name="ps_container_title" msgid="4391796149519594205">"Privati"</string>
     <string name="ps_container_settings" msgid="6059734123353320479">"Privačios erdvės nustatymai"</string>
     <string name="ps_container_unlock_button_content_description" msgid="9181551784092204234">"Privatus, atrakintas."</string>
     <string name="ps_container_lock_button_content_description" msgid="5961993384382649530">"Privatus, užrakintas."</string>
diff --git a/res/values-lv/strings.xml b/res/values-lv/strings.xml
index e3e4c57..3eafd9a 100644
--- a/res/values-lv/strings.xml
+++ b/res/values-lv/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Samazināt platumu"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Samazināt augstumu"</string>
     <string name="widget_resized" msgid="9130327887929620">"Logrīka lielums mainīts — platums: <xliff:g id="NUMBER_0">%1$s</xliff:g>, augstums: <xliff:g id="NUMBER_1">%2$s</xliff:g>."</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Saīsnes izvēlne"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Nerādīt"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Aizvērt"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Personīgās lietotnes"</string>
@@ -200,7 +199,7 @@
     <string name="remote_action_failed" msgid="1383965239183576790">"Neizdevās: <xliff:g id="WHAT">%1$s</xliff:g>"</string>
     <string name="private_space_label" msgid="2359721649407947001">"Privātā telpa"</string>
     <string name="private_space_secondary_label" msgid="9203933341714508907">"Pieskarieties, lai iestatītu vai atvērtu"</string>
-    <string name="ps_container_title" msgid="4391796149519594205">"Privātā mape"</string>
+    <string name="ps_container_title" msgid="4391796149519594205">"Privātā telpa"</string>
     <string name="ps_container_settings" msgid="6059734123353320479">"Privātās mapes iestatījumi"</string>
     <string name="ps_container_unlock_button_content_description" msgid="9181551784092204234">"Privāta un nav bloķēta."</string>
     <string name="ps_container_lock_button_content_description" msgid="5961993384382649530">"Privāta un bloķēta."</string>
diff --git a/res/values-mk/strings.xml b/res/values-mk/strings.xml
index b16a135..2b85e12 100644
--- a/res/values-mk/strings.xml
+++ b/res/values-mk/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Намали ширина"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Намали висина"</string>
     <string name="widget_resized" msgid="9130327887929620">"Големината на виџетот е променета на ширина <xliff:g id="NUMBER_0">%1$s</xliff:g> висина <xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Мени за кратенки"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Отфрли"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Затвори"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Лично"</string>
diff --git a/res/values-ml/strings.xml b/res/values-ml/strings.xml
index 2fd018e..df98b72 100644
--- a/res/values-ml/strings.xml
+++ b/res/values-ml/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"വീതി കുറയ്‌ക്കുക"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"ഉയരം കുറയ്‌ക്കുക"</string>
     <string name="widget_resized" msgid="9130327887929620">"വീതി <xliff:g id="NUMBER_0">%1$s</xliff:g> ഉയരം <xliff:g id="NUMBER_1">%2$s</xliff:g>-ലേക്ക് വിഡ്‌ജെറ്റിന്റെ വലുപ്പം മാറ്റി"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"കുറുക്കുവഴി മെനു"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"നിരസിക്കുക"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"അടയ്ക്കൂ"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"വ്യക്തിപരം"</string>
diff --git a/res/values-mn/strings.xml b/res/values-mn/strings.xml
index 6a051d5..9fdaf13 100644
--- a/res/values-mn/strings.xml
+++ b/res/values-mn/strings.xml
@@ -32,7 +32,7 @@
     <string name="split_app_info_accessibility" msgid="5475288491241414932">"%1$s-н аппын мэдээлэл"</string>
     <string name="split_app_usage_settings" msgid="7214375263347964093">"%1$s-н ашиглалтын тохиргоо"</string>
     <string name="new_window_option_taskbar" msgid="6448780542727767211">"Шинэ цонх"</string>
-    <string name="manage_windows_option_taskbar" msgid="2294109489960654212">"Windows-г удирдах"</string>
+    <string name="manage_windows_option_taskbar" msgid="2294109489960654212">"Цонхнуудыг удирдах"</string>
     <string name="save_app_pair" msgid="5647523853662686243">"Апп хослуулалтыг хадгалах"</string>
     <string name="app_pair_default_title" msgid="4045241727446873529">"<xliff:g id="APP1">%1$s</xliff:g> | <xliff:g id="APP2">%2$s</xliff:g>"</string>
     <string name="app_pair_unlaunchable_at_screen_size" msgid="3446551575502685376">"Энэ апп хослуулалтыг уг төхөөрөмж дээр дэмждэггүй"</string>
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Нарийсгах"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Намсгах"</string>
     <string name="widget_resized" msgid="9130327887929620">"Виджэтийн өргөн <xliff:g id="NUMBER_0">%1$s</xliff:g>, өндөр <xliff:g id="NUMBER_1">%2$s</xliff:g> болсон"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Товчлолын цэс"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Хаах"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Хаах"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Хувийн"</string>
@@ -200,7 +199,7 @@
     <string name="remote_action_failed" msgid="1383965239183576790">"Амжилтгүй болсон: <xliff:g id="WHAT">%1$s</xliff:g>"</string>
     <string name="private_space_label" msgid="2359721649407947001">"Хувийн орон зай"</string>
     <string name="private_space_secondary_label" msgid="9203933341714508907">"Тохируулах эсвэл нээхийн тулд товших"</string>
-    <string name="ps_container_title" msgid="4391796149519594205">"Хувийн"</string>
+    <string name="ps_container_title" msgid="4391796149519594205">"Хаалттай"</string>
     <string name="ps_container_settings" msgid="6059734123353320479">"Private Space-н тохиргоо"</string>
     <string name="ps_container_unlock_button_content_description" msgid="9181551784092204234">"Хувийн, түгжээг тайлсан."</string>
     <string name="ps_container_lock_button_content_description" msgid="5961993384382649530">"Хувийн, түгжээтэй."</string>
diff --git a/res/values-mr/strings.xml b/res/values-mr/strings.xml
index dba75d9..e596193 100644
--- a/res/values-mr/strings.xml
+++ b/res/values-mr/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"रुंदी कमी करा"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"उंची कमी करा"</string>
     <string name="widget_resized" msgid="9130327887929620">"विजेटचा आकार रुंदी <xliff:g id="NUMBER_0">%1$s</xliff:g> उंची <xliff:g id="NUMBER_1">%2$s</xliff:g> मध्ये बदलला"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"शॉर्टकट मेनू"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"डिसमिस करा"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"बंद करा"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"वैयक्तिक"</string>
diff --git a/res/values-ms/strings.xml b/res/values-ms/strings.xml
index 019fb49..91c85de 100644
--- a/res/values-ms/strings.xml
+++ b/res/values-ms/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Kurangkan kelebaran"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Kurangkan ketinggian"</string>
     <string name="widget_resized" msgid="9130327887929620">"Saiz widget diubah menjadi <xliff:g id="NUMBER_0">%1$s</xliff:g> lebar <xliff:g id="NUMBER_1">%2$s</xliff:g> tinggi"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Menu Pintasan"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Ketepikan"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Tutup"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Peribadi"</string>
diff --git a/res/values-my/strings.xml b/res/values-my/strings.xml
index 4b907b4..8ed7980 100644
--- a/res/values-my/strings.xml
+++ b/res/values-my/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"အကျယ်အား လျှော့ပါ"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"အမြင့်အား လျှော့ပါ"</string>
     <string name="widget_resized" msgid="9130327887929620">"Widget အား အကျယ် <xliff:g id="NUMBER_0">%1$s</xliff:g> အမြင့် <xliff:g id="NUMBER_1">%2$s</xliff:g> အရွယ်အစားပြန်လည်ချိန်ညှိပြီး၏"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"ဖြတ်လမ်းလင့်ခ် မီနူး"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"ပယ်ရန်"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"ပိတ်ရန်"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"ကိုယ်ပိုင်"</string>
diff --git a/res/values-nb/strings.xml b/res/values-nb/strings.xml
index 0a94172..fa7a047 100644
--- a/res/values-nb/strings.xml
+++ b/res/values-nb/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Reduser bredden"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Reduser høyden"</string>
     <string name="widget_resized" msgid="9130327887929620">"Størrelsen på modulen er endret til bredde <xliff:g id="NUMBER_0">%1$s</xliff:g> og høyde <xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Hurtigtastmeny"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Avvis"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Lukk"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Personlig"</string>
diff --git a/res/values-ne/strings.xml b/res/values-ne/strings.xml
index bf3d798..86ebc7b 100644
--- a/res/values-ne/strings.xml
+++ b/res/values-ne/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"चौडाइ घटाउनुहोस्"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"उँचाइ घटाउनुहोस्"</string>
     <string name="widget_resized" msgid="9130327887929620">"विजेट चौडाइ <xliff:g id="NUMBER_0">%1$s</xliff:g> उचाइ <xliff:g id="NUMBER_1">%2$s</xliff:g> मा पुनः आकार मिलाइयो"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"सर्टकटसम्बन्धी मेनु"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"खारेज गर्नुहोस्"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"बन्द गर्नुहोस्"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"व्यक्तिगत"</string>
@@ -200,7 +199,7 @@
     <string name="remote_action_failed" msgid="1383965239183576790">"कार्य पूरा गर्न सकिएन: <xliff:g id="WHAT">%1$s</xliff:g>"</string>
     <string name="private_space_label" msgid="2359721649407947001">"निजी स्पेस"</string>
     <string name="private_space_secondary_label" msgid="9203933341714508907">"सेटअप गर्न वा खोल्न ट्याप गर्नुहोस्"</string>
-    <string name="ps_container_title" msgid="4391796149519594205">"निजी"</string>
+    <string name="ps_container_title" msgid="4391796149519594205">"निजी स्पेस"</string>
     <string name="ps_container_settings" msgid="6059734123353320479">"निजी स्पेससम्बन्धी सेटिङ"</string>
     <string name="ps_container_unlock_button_content_description" msgid="9181551784092204234">"निजी, अनलक गरिएको।"</string>
     <string name="ps_container_lock_button_content_description" msgid="5961993384382649530">"निजी, लक गरिएको।"</string>
diff --git a/res/values-nl/strings.xml b/res/values-nl/strings.xml
index b275b7c..1e3e166 100644
--- a/res/values-nl/strings.xml
+++ b/res/values-nl/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Breedte verkleinen"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Hoogte verkleinen"</string>
     <string name="widget_resized" msgid="9130327887929620">"Formaat van widget gewijzigd in breedte <xliff:g id="NUMBER_0">%1$s</xliff:g> en hoogte <xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Snelmenu"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Sluiten"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Sluiten"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Privé"</string>
diff --git a/res/values-or/strings.xml b/res/values-or/strings.xml
index ab9bd61..f8d68ae 100644
--- a/res/values-or/strings.xml
+++ b/res/values-or/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"ଚଉଡ଼ା କମ୍‌ କରନ୍ତୁ"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"ଉଚ୍ଚତା କମ୍‌ କରନ୍ତୁ"</string>
     <string name="widget_resized" msgid="9130327887929620">"ୱିଜେଟକୁ <xliff:g id="NUMBER_0">%1$s</xliff:g> ଓସାର ଓ <xliff:g id="NUMBER_1">%2$s</xliff:g> ଉଚ୍ଚରେ ପୁନଃଆକାର ଦିଆଗଲା"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"ସର୍ଟକଟ ମେନୁ"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"ଖାରଜ କରନ୍ତୁ"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"ବନ୍ଦ କରନ୍ତୁ"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"ବ୍ୟକ୍ତିଗତ"</string>
diff --git a/res/values-pa/strings.xml b/res/values-pa/strings.xml
index 440c504..07aae76 100644
--- a/res/values-pa/strings.xml
+++ b/res/values-pa/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"ਚੌੜਾਈ ਘਟਾਓ"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"ਉਂਚਾਈ ਘਟਾਓ"</string>
     <string name="widget_resized" msgid="9130327887929620">"ਵਿਜੈਟ ਨੂੰ ਚੌੜਾਈ <xliff:g id="NUMBER_0">%1$s</xliff:g> ਉਂਚਾਈ <xliff:g id="NUMBER_1">%2$s</xliff:g> ਨੂੰ ਮੁੜ ਆਕਾਰ ਦਿੱਤਾ"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"ਸ਼ਾਰਟਕੱਟ ਮੀਨੂ"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"ਖਾਰਜ ਕਰੋ"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"ਬੰਦ ਕਰੋ"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"ਨਿੱਜੀ"</string>
@@ -200,7 +199,7 @@
     <string name="remote_action_failed" msgid="1383965239183576790">"ਇਹ ਕਾਰਵਾਈ ਅਸਫਲ ਹੋਈ: <xliff:g id="WHAT">%1$s</xliff:g>"</string>
     <string name="private_space_label" msgid="2359721649407947001">"ਪ੍ਰਾਈਵੇਟ ਸਪੇਸ"</string>
     <string name="private_space_secondary_label" msgid="9203933341714508907">"ਸੈੱਟਅੱਪ ਕਰਨ ਜਾਂ ਖੋਲ੍ਹਣ ਲਈ ਟੈਪ ਕਰੋ"</string>
-    <string name="ps_container_title" msgid="4391796149519594205">"ਨਿੱਜੀ"</string>
+    <string name="ps_container_title" msgid="4391796149519594205">"ਪ੍ਰਾਈਵੇਟ"</string>
     <string name="ps_container_settings" msgid="6059734123353320479">"ਪ੍ਰਾਈਵੇਟ ਸਪੇਸ ਸੰਬੰਧੀ ਸੈਟਿੰਗਾਂ"</string>
     <string name="ps_container_unlock_button_content_description" msgid="9181551784092204234">"ਨਿੱਜੀ, ਅਣਲਾਕ ਕੀਤਾ ਗਿਆ।"</string>
     <string name="ps_container_lock_button_content_description" msgid="5961993384382649530">"ਨਿੱਜੀ, ਲਾਕ ਕੀਤਾ ਗਿਆ।"</string>
diff --git a/res/values-pl/strings.xml b/res/values-pl/strings.xml
index ca00d6c..f76e37b 100644
--- a/res/values-pl/strings.xml
+++ b/res/values-pl/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Zmniejsz szerokość"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Zmniejsz wysokość"</string>
     <string name="widget_resized" msgid="9130327887929620">"Szerokość i wysokość widżetu zmieniła się na <xliff:g id="NUMBER_0">%1$s</xliff:g> x <xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Menu skrótów"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Zamknij"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Zamknij"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Osobiste"</string>
diff --git a/res/values-pt-rPT/strings.xml b/res/values-pt-rPT/strings.xml
index a6b2929..66dc18f 100644
--- a/res/values-pt-rPT/strings.xml
+++ b/res/values-pt-rPT/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Diminuir largura"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Diminuir altura"</string>
     <string name="widget_resized" msgid="9130327887929620">"Widget redimensionado para a largura <xliff:g id="NUMBER_0">%1$s</xliff:g>, altura <xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Menu de atalho"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Ignorar"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Fechar"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Pessoal"</string>
diff --git a/res/values-pt/strings.xml b/res/values-pt/strings.xml
index 606e1d7..b9ead80 100644
--- a/res/values-pt/strings.xml
+++ b/res/values-pt/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Diminuir largura"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Diminuir altura"</string>
     <string name="widget_resized" msgid="9130327887929620">"Widget redimensionado para a largura <xliff:g id="NUMBER_0">%1$s</xliff:g>, altura <xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Menu de atalhos"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Dispensar"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Fechar"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Pessoais"</string>
@@ -200,7 +199,7 @@
     <string name="remote_action_failed" msgid="1383965239183576790">"Falha: <xliff:g id="WHAT">%1$s</xliff:g>"</string>
     <string name="private_space_label" msgid="2359721649407947001">"Espaço privado"</string>
     <string name="private_space_secondary_label" msgid="9203933341714508907">"Toque para configurar ou abrir"</string>
-    <string name="ps_container_title" msgid="4391796149519594205">"Particular"</string>
+    <string name="ps_container_title" msgid="4391796149519594205">"Privado"</string>
     <string name="ps_container_settings" msgid="6059734123353320479">"Configurações do Espaço particular"</string>
     <string name="ps_container_unlock_button_content_description" msgid="9181551784092204234">"Privada, desbloqueado."</string>
     <string name="ps_container_lock_button_content_description" msgid="5961993384382649530">"Privada, bloqueado."</string>
diff --git a/res/values-ro/strings.xml b/res/values-ro/strings.xml
index 092c89e..73a5ffb 100644
--- a/res/values-ro/strings.xml
+++ b/res/values-ro/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Redu lățimea"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Redu înălțimea"</string>
     <string name="widget_resized" msgid="9130327887929620">"Widgetul a fost redimensionat la lățimea <xliff:g id="NUMBER_0">%1$s</xliff:g> și înălțimea <xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Meniu de comenzi rapide"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Închide"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Închide"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Personale"</string>
diff --git a/res/values-ru/strings.xml b/res/values-ru/strings.xml
index 0c8ec40..54a1024 100644
--- a/res/values-ru/strings.xml
+++ b/res/values-ru/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Уменьшить ширину"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Уменьшить высоту"</string>
     <string name="widget_resized" msgid="9130327887929620">"Изменен размер виджета: до <xliff:g id="NUMBER_0">%1$s</xliff:g> в ширину и <xliff:g id="NUMBER_1">%2$s</xliff:g> в высоту"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Быстрое меню"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Закрыть"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Закрыть"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Личные"</string>
diff --git a/res/values-si/strings.xml b/res/values-si/strings.xml
index 6e2fc2a..21ac9ac 100644
--- a/res/values-si/strings.xml
+++ b/res/values-si/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"පළල අඩු කරන්න"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"උස අඩු කරන්න"</string>
     <string name="widget_resized" msgid="9130327887929620">"විජට් පළල <xliff:g id="NUMBER_0">%1$s</xliff:g> උස <xliff:g id="NUMBER_1">%2$s</xliff:g> වෙත ප්‍රමාණකරණය කරන ලදි"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"කෙටිමං මෙනුව"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"ඉවතලන්න"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"වසන්න"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"පුද්ගලික"</string>
diff --git a/res/values-sk/strings.xml b/res/values-sk/strings.xml
index b8de977..bf96af6 100644
--- a/res/values-sk/strings.xml
+++ b/res/values-sk/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Znížiť šírku"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Znížiť výšku"</string>
     <string name="widget_resized" msgid="9130327887929620">"Veľkosť miniaplikácie bola zmenená na <xliff:g id="NUMBER_0">%1$s</xliff:g> x <xliff:g id="NUMBER_1">%2$s</xliff:g> (šírka x výška)"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Ponuka skratiek"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Zavrieť"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Zavrieť"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Osobné"</string>
diff --git a/res/values-sl/strings.xml b/res/values-sl/strings.xml
index 70e8e2e..b7ecd50 100644
--- a/res/values-sl/strings.xml
+++ b/res/values-sl/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Zmanjšanje širine"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Zmanjšanje višine"</string>
     <string name="widget_resized" msgid="9130327887929620">"Velikost pripomočka je bila spremenjena na <xliff:g id="NUMBER_0">%1$s</xliff:g> širine in <xliff:g id="NUMBER_1">%2$s</xliff:g> višine"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Meni z bližnjicami"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Opusti"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Zapri"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Osebno"</string>
diff --git a/res/values-sq/strings.xml b/res/values-sq/strings.xml
index 3fb73e6..64bb03f 100644
--- a/res/values-sq/strings.xml
+++ b/res/values-sq/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Zvogëlo gjerësinë"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Zvogëlo lartësinë"</string>
     <string name="widget_resized" msgid="9130327887929620">"Madhësia e miniaplikacionit u ndryshua me gjerësinë <xliff:g id="NUMBER_0">%1$s</xliff:g> dhe lartësinë <xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Menyja e shkurtoreve"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Hiqe"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Mbyll"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Personale"</string>
diff --git a/res/values-sr/strings.xml b/res/values-sr/strings.xml
index 1997f54..44bc9b5 100644
--- a/res/values-sr/strings.xml
+++ b/res/values-sr/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Смањи ширину"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Смањи висину"</string>
     <string name="widget_resized" msgid="9130327887929620">"Величина виџета је промењена на ширину <xliff:g id="NUMBER_0">%1$s</xliff:g> и висину <xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Мени са пречицама"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Одбаци"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Затвори"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Лично"</string>
diff --git a/res/values-sv/strings.xml b/res/values-sv/strings.xml
index 2d34ee9..217e116 100644
--- a/res/values-sv/strings.xml
+++ b/res/values-sv/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Minska bredden"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Minska höjden"</string>
     <string name="widget_resized" msgid="9130327887929620">"Widgetens storlek har ändrats till: bredd <xliff:g id="NUMBER_0">%1$s</xliff:g>, höjd <xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Snabbmeny"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Ignorera"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Stäng"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Privat"</string>
diff --git a/res/values-sw/strings.xml b/res/values-sw/strings.xml
index e258b0e..4a2db28 100644
--- a/res/values-sw/strings.xml
+++ b/res/values-sw/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Punguza upana"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Punguza urefu"</string>
     <string name="widget_resized" msgid="9130327887929620">"Wijeti imepunguzwa hadi upana <xliff:g id="NUMBER_0">%1$s</xliff:g> urefu <xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Menyu ya Njia za Mkato"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Ondoa"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Funga"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Binafsi"</string>
@@ -200,7 +199,7 @@
     <string name="remote_action_failed" msgid="1383965239183576790">"Hitilafu: <xliff:g id="WHAT">%1$s</xliff:g>"</string>
     <string name="private_space_label" msgid="2359721649407947001">"Nafasi ya faragha"</string>
     <string name="private_space_secondary_label" msgid="9203933341714508907">"Gusa uweke mipangilio au ufungue"</string>
-    <string name="ps_container_title" msgid="4391796149519594205">"Faragha"</string>
+    <string name="ps_container_title" msgid="4391796149519594205">"Sehemu ya Faragha"</string>
     <string name="ps_container_settings" msgid="6059734123353320479">"Mipangilio ya Nafasi ya Faragha"</string>
     <string name="ps_container_unlock_button_content_description" msgid="9181551784092204234">"Ya faragha, imefunguliwa."</string>
     <string name="ps_container_lock_button_content_description" msgid="5961993384382649530">"Ya faragha, imefungwa."</string>
diff --git a/res/values-ta/strings.xml b/res/values-ta/strings.xml
index 643bad3..e724f36 100644
--- a/res/values-ta/strings.xml
+++ b/res/values-ta/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"அகலத்தைக் குறை"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"உயரத்தைக் குறை"</string>
     <string name="widget_resized" msgid="9130327887929620">"அகலம் <xliff:g id="NUMBER_0">%1$s</xliff:g> மற்றும் உயரம் <xliff:g id="NUMBER_1">%2$s</xliff:g>க்கு விட்ஜெட் அளவு மாற்றப்பட்டது"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"ஷார்ட்கட் மெனு"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"நிராகரி"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"மூடும் பட்டன்"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"தனிப்பட்டவை"</string>
@@ -198,9 +197,9 @@
     <string name="work_scheduler_button_content_description" msgid="917340740986764967">"பணி ஆப்ஸுக்கான திட்ட அட்டவணை"</string>
     <string name="developer_options_filter_hint" msgid="5896817443635989056">"வடிப்பான்"</string>
     <string name="remote_action_failed" msgid="1383965239183576790">"தோல்வி: <xliff:g id="WHAT">%1$s</xliff:g>"</string>
-    <string name="private_space_label" msgid="2359721649407947001">"தனிப்பட்ட சேமிப்பிடம்"</string>
+    <string name="private_space_label" msgid="2359721649407947001">"ரகசிய இடம்"</string>
     <string name="private_space_secondary_label" msgid="9203933341714508907">"அமைக்கவோ திறக்கவோ தட்டுங்கள்"</string>
-    <string name="ps_container_title" msgid="4391796149519594205">"தனிப்பட்டது"</string>
+    <string name="ps_container_title" msgid="4391796149519594205">"ரகசிய இடம்"</string>
     <string name="ps_container_settings" msgid="6059734123353320479">"தனிப்பட்ட சேமிப்பிட அமைப்புகள்"</string>
     <string name="ps_container_unlock_button_content_description" msgid="9181551784092204234">"தனிப்பட்டது, அன்லாக் செய்யப்பட்டுள்ளது."</string>
     <string name="ps_container_lock_button_content_description" msgid="5961993384382649530">"தனிப்பட்டது, லாக் செய்யப்பட்டுள்ளது."</string>
diff --git a/res/values-te/strings.xml b/res/values-te/strings.xml
index ddd988d..186e94d 100644
--- a/res/values-te/strings.xml
+++ b/res/values-te/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"వెడల్పును తగ్గించు"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"ఎత్తును తగ్గించు"</string>
     <string name="widget_resized" msgid="9130327887929620">"విడ్జెట్ సైజ్‌ వెడల్పు <xliff:g id="NUMBER_0">%1$s</xliff:g>కి, ఎత్తు <xliff:g id="NUMBER_1">%2$s</xliff:g>కి మార్చబడింది"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"షార్ట్‌కట్ మెనూ"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"తీసివేయండి"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"మూసివేస్తుంది"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"వ్యక్తిగతం"</string>
diff --git a/res/values-th/strings.xml b/res/values-th/strings.xml
index 13cd092..b5373f6 100644
--- a/res/values-th/strings.xml
+++ b/res/values-th/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"ลดความกว้าง"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"ลดความสูง"</string>
     <string name="widget_resized" msgid="9130327887929620">"ปรับขนาดของวิดเจ็ตเป็นกว้าง <xliff:g id="NUMBER_0">%1$s</xliff:g> สูง <xliff:g id="NUMBER_1">%2$s</xliff:g> แล้ว"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"เมนูแป้นพิมพ์ลัด"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"ปิด"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"ปิด"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"ส่วนตัว"</string>
diff --git a/res/values-tl/strings.xml b/res/values-tl/strings.xml
index 58030f0..7bc7f9d 100644
--- a/res/values-tl/strings.xml
+++ b/res/values-tl/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Bawasan ang lapad"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Bawasan ang taas"</string>
     <string name="widget_resized" msgid="9130327887929620">"Na-resize ang widget sa lapad <xliff:g id="NUMBER_0">%1$s</xliff:g> taas <xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Menu ng Shortcut"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"I-dismiss"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Isara"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Personal"</string>
diff --git a/res/values-tr/strings.xml b/res/values-tr/strings.xml
index 2def2ac..9990967 100644
--- a/res/values-tr/strings.xml
+++ b/res/values-tr/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Genişliği azalt"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Yüksekliği azalt"</string>
     <string name="widget_resized" msgid="9130327887929620">"Widget, <xliff:g id="NUMBER_0">%1$s</xliff:g> genişlik ve <xliff:g id="NUMBER_1">%2$s</xliff:g> yükseklik değerine yeniden boyutlandırıldı"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Kısayol Menüsü"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Kapat"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Kapat"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Kişisel"</string>
@@ -200,7 +199,7 @@
     <string name="remote_action_failed" msgid="1383965239183576790">"Başarısız: <xliff:g id="WHAT">%1$s</xliff:g>"</string>
     <string name="private_space_label" msgid="2359721649407947001">"Gizli alan"</string>
     <string name="private_space_secondary_label" msgid="9203933341714508907">"Kurmak veya açmak için dokunun"</string>
-    <string name="ps_container_title" msgid="4391796149519594205">"Gizli"</string>
+    <string name="ps_container_title" msgid="4391796149519594205">"Özel"</string>
     <string name="ps_container_settings" msgid="6059734123353320479">"Gizli Alan Ayarları"</string>
     <string name="ps_container_unlock_button_content_description" msgid="9181551784092204234">"Gizli, kilidi açık."</string>
     <string name="ps_container_lock_button_content_description" msgid="5961993384382649530">"Gizli, kilitli."</string>
diff --git a/res/values-uk/strings.xml b/res/values-uk/strings.xml
index 0f0752c..165ab49 100644
--- a/res/values-uk/strings.xml
+++ b/res/values-uk/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Зменшити ширину"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Зменшити висоту"</string>
     <string name="widget_resized" msgid="9130327887929620">"Розміри віджета змінено на <xliff:g id="NUMBER_0">%1$s</xliff:g> завширшки та <xliff:g id="NUMBER_1">%2$s</xliff:g> заввишки"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Меню швидкого доступу"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Закрити"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Закрити"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Особисті додатки"</string>
diff --git a/res/values-ur/strings.xml b/res/values-ur/strings.xml
index 260ae25..1bd2e4a 100644
--- a/res/values-ur/strings.xml
+++ b/res/values-ur/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"چوڑائی کم کریں"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"اونچائی کم کریں"</string>
     <string name="widget_resized" msgid="9130327887929620">"ویجیٹ کے سائز کو چوڑائی <xliff:g id="NUMBER_0">%1$s</xliff:g> اونچائی <xliff:g id="NUMBER_1">%2$s</xliff:g> میں تبدیل کر دیا گیا"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"شارٹ کٹ مینیو"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"برخاست کریں"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"بند کریں"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"ذاتی"</string>
@@ -200,7 +199,7 @@
     <string name="remote_action_failed" msgid="1383965239183576790">"ناکام ہو گيا: <xliff:g id="WHAT">%1$s</xliff:g>"</string>
     <string name="private_space_label" msgid="2359721649407947001">"نجی اسپیس"</string>
     <string name="private_space_secondary_label" msgid="9203933341714508907">"سیٹ اپ کرنے یا کھولنے کے لیے تھپتھپائیں"</string>
-    <string name="ps_container_title" msgid="4391796149519594205">"نجی"</string>
+    <string name="ps_container_title" msgid="4391796149519594205">"پرائیویٹ"</string>
     <string name="ps_container_settings" msgid="6059734123353320479">"نجی اسپیس کی ترتیبات"</string>
     <string name="ps_container_unlock_button_content_description" msgid="9181551784092204234">"نجی اسپیس غیر مقفل ہے۔"</string>
     <string name="ps_container_lock_button_content_description" msgid="5961993384382649530">"نجی اسپیس مقفل ہے۔"</string>
diff --git a/res/values-uz/strings.xml b/res/values-uz/strings.xml
index ecd72f6..b9286ec 100644
--- a/res/values-uz/strings.xml
+++ b/res/values-uz/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Enini kichraytirish"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Bo‘yini kichraytirish"</string>
     <string name="widget_resized" msgid="9130327887929620">"Vidjetning eni <xliff:g id="NUMBER_0">%1$s</xliff:g>, bo‘yi <xliff:g id="NUMBER_1">%2$s</xliff:g> qilib o‘zgartirildi"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Tezkor tugma menyusi"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Yopish"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Yopish"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Shaxsiy"</string>
diff --git a/res/values-vi/strings.xml b/res/values-vi/strings.xml
index 03e048e0..6082ef6 100644
--- a/res/values-vi/strings.xml
+++ b/res/values-vi/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Giảm chiều rộng"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Giảm chiều cao"</string>
     <string name="widget_resized" msgid="9130327887929620">"Đã đổi kích thước tiện ích thành chiều rộng <xliff:g id="NUMBER_0">%1$s</xliff:g> chiều cao <xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Trình đơn lối tắt"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Loại bỏ"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Đóng"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Cá nhân"</string>
diff --git a/res/values-zh-rCN/strings.xml b/res/values-zh-rCN/strings.xml
index 356e6e5..c1917a9 100644
--- a/res/values-zh-rCN/strings.xml
+++ b/res/values-zh-rCN/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"减小宽度"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"减小高度"</string>
     <string name="widget_resized" msgid="9130327887929620">"微件尺寸已调整为：宽度 <xliff:g id="NUMBER_0">%1$s</xliff:g>，高度 <xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"快捷键菜单"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"关闭"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"关闭"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"个人"</string>
diff --git a/res/values-zh-rHK/strings.xml b/res/values-zh-rHK/strings.xml
index b9e31dc..d29653c 100644
--- a/res/values-zh-rHK/strings.xml
+++ b/res/values-zh-rHK/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"減少闊度"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"減少高度"</string>
     <string name="widget_resized" msgid="9130327887929620">"已調整小工具的大小至闊 <xliff:g id="NUMBER_0">%1$s</xliff:g> 高 <xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"快速鍵選單"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"關閉"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"關閉"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"個人"</string>
diff --git a/res/values-zh-rTW/strings.xml b/res/values-zh-rTW/strings.xml
index 2db315b..eaa5a73 100644
--- a/res/values-zh-rTW/strings.xml
+++ b/res/values-zh-rTW/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"減少寬度"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"減少高度"</string>
     <string name="widget_resized" msgid="9130327887929620">"已將小工具的寬度和高度分別調整為 <xliff:g id="NUMBER_0">%1$s</xliff:g> 和 <xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"快速鍵選單"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"關閉"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"關閉"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"個人"</string>
diff --git a/res/values-zu/strings.xml b/res/values-zu/strings.xml
index 10f425d..60dffeb 100644
--- a/res/values-zu/strings.xml
+++ b/res/values-zu/strings.xml
@@ -178,8 +178,7 @@
     <string name="action_decrease_width" msgid="1374549771083094654">"Nciphisa ububanzi"</string>
     <string name="action_decrease_height" msgid="282377193880900022">"Nciphisa ubude"</string>
     <string name="widget_resized" msgid="9130327887929620">"Iwijethi inikezwe usayizi omusha ngobubanzi obungu-<xliff:g id="NUMBER_0">%1$s</xliff:g> ubude obungu-<xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
-    <!-- no translation found for action_deep_shortcut (4766835855579976045) -->
-    <skip />
+    <string name="action_deep_shortcut" msgid="4766835855579976045">"Imenyu Yezinqamuleli"</string>
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Cashisa"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Vala"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Okomuntu siqu"</string>
diff --git a/res/values/attrs.xml b/res/values/attrs.xml
index 887a708..c477633 100644
--- a/res/values/attrs.xml
+++ b/res/values/attrs.xml
@@ -163,8 +163,8 @@
     </declare-styleable>
 
     <declare-styleable name="GridDimension">
-        <attr name="minDeviceWidthPx" format="float"/>
-        <attr name="minDeviceHeightPx" format="float"/>
+        <attr name="minDeviceWidthDp" format="integer"/>
+        <attr name="minDeviceHeightDp" format="integer"/>
         <attr name="numGridDimension" format="integer"/>
         <attr name="dbFile" />
         <attr name="defaultLayoutId"/>
diff --git a/res/values/dimens.xml b/res/values/dimens.xml
index 326ee06..c0bd956 100644
--- a/res/values/dimens.xml
+++ b/res/values/dimens.xml
@@ -173,13 +173,16 @@
     <dimen name="work_edu_card_margin">16dp</dimen>
     <dimen name="work_edu_card_radius">16dp</dimen>
     <dimen name="work_edu_card_bottom_margin">26dp</dimen>
-    <dimen name="work_edu_card_text_end_margin">32dp</dimen>
+    <dimen name="work_edu_card_text_end_margin">12dp</dimen>
     <dimen name="work_apps_paused_button_stroke">1dp</dimen>
+    <dimen name="work_edu_card_button_margin_top">12dp</dimen>
 
     <dimen name="work_card_margin">24dp</dimen>
+    <dimen name="work_card_margin_end">12dp</dimen>
     <!-- (x) icon button inside work edu card -->
-    <dimen name="rounded_button_width">24dp</dimen>
+    <dimen name="rounded_button_width">48dp</dimen>
     <dimen name="x_icon_size">16dp</dimen>
+    <dimen name="inset_rounded_action_button">12dp</dimen>
 
     <!-- rounded button shown inside card views, and snack bars  -->
     <dimen name="padded_rounded_button_height">48dp</dimen>
diff --git a/src/com/android/launcher3/BubbleTextView.java b/src/com/android/launcher3/BubbleTextView.java
index eaa720e..247ee48 100644
--- a/src/com/android/launcher3/BubbleTextView.java
+++ b/src/com/android/launcher3/BubbleTextView.java
@@ -980,7 +980,7 @@
     public boolean shouldDrawAppContrastTile() {
         return mDisplay == DISPLAY_WORKSPACE && shouldTextBeVisible()
                 && PillColorProvider.getInstance(getContext()).isMatchaEnabled()
-                && enableContrastTiles() && TextUtils.isEmpty(getText());
+                && enableContrastTiles() && !TextUtils.isEmpty(getText());
     }
 
     public void setTextVisibility(boolean visible) {
diff --git a/src/com/android/launcher3/CellLayout.java b/src/com/android/launcher3/CellLayout.java
index ee72c22..df5f520 100644
--- a/src/com/android/launcher3/CellLayout.java
+++ b/src/com/android/launcher3/CellLayout.java
@@ -71,6 +71,7 @@
 import com.android.launcher3.model.data.LauncherAppWidgetInfo;
 import com.android.launcher3.util.CellAndSpan;
 import com.android.launcher3.util.GridOccupancy;
+import com.android.launcher3.util.MSDLPlayerWrapper;
 import com.android.launcher3.util.MultiTranslateDelegate;
 import com.android.launcher3.util.ParcelableSparseArray;
 import com.android.launcher3.util.Themes;
@@ -78,6 +79,8 @@
 import com.android.launcher3.views.ActivityContext;
 import com.android.launcher3.widget.LauncherAppWidgetHostView;
 
+import com.google.android.msdl.data.model.MSDLToken;
+
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.util.ArrayList;
@@ -204,6 +207,8 @@
 
     private static final Paint sPaint = new Paint();
 
+    private final MSDLPlayerWrapper mMSDLPlayerWrapper;
+
     // Related to accessible drag and drop
     DragAndDropAccessibilityDelegate mTouchHelper;
 
@@ -237,6 +242,8 @@
         mContainerType = a.getInteger(R.styleable.CellLayout_containerType, WORKSPACE);
         a.recycle();
 
+        mMSDLPlayerWrapper = MSDLPlayerWrapper.INSTANCE.get(context);
+
         // A ViewGroup usually does not draw, but CellLayout needs to draw a rectangle to show
         // the user where a dragged item will land when dropped.
         setWillNotDraw(false);
@@ -1153,6 +1160,9 @@
             DropTarget.DragObject dragObject) {
         if (mDragCell[0] != cellX || mDragCell[1] != cellY || mDragCellSpan[0] != spanX
                 || mDragCellSpan[1] != spanY) {
+            if (Flags.msdlFeedback()) {
+                mMSDLPlayerWrapper.playToken(MSDLToken.DRAG_INDICATOR_DISCRETE);
+            }
             mDragCell[0] = cellX;
             mDragCell[1] = cellY;
             mDragCellSpan[0] = spanX;
diff --git a/src/com/android/launcher3/InvariantDeviceProfile.java b/src/com/android/launcher3/InvariantDeviceProfile.java
index e1d84be..c044c52 100644
--- a/src/com/android/launcher3/InvariantDeviceProfile.java
+++ b/src/com/android/launcher3/InvariantDeviceProfile.java
@@ -654,9 +654,9 @@
      * Parses through the xml to find GridDimension specs. Then calls findBestRowCount to get the
      * correct row count for this GridOption.
      *
-     * @return the result of {@link #findBestRowCount(List, Info)}.
+     * @return the result of {@link #findBestRowCount(List, int, int)}.
      */
-    public static GridDimension getRowCount(ResourceHelper resourceHelper, Context context,
+    private static GridDimension getRowCount(ResourceHelper resourceHelper, Context context,
             Info displayInfo) {
         ArrayList<GridDimension> rowCounts = new ArrayList<>();
 
@@ -674,24 +674,40 @@
             throw new RuntimeException(e);
         }
 
-        return findBestRowCount(rowCounts, displayInfo);
+        // Finds the min width and height in dp for all displays.
+        int[] dimens = findMinWidthAndHeightDpForDevice(displayInfo);
+
+        return findBestRowCount(rowCounts, dimens[0], dimens[1]);
     }
 
     /**
      * @return the biggest row count that fits the display dimensions spec using GridDimension to
-     * determine that. If no best row count is found, return -1.
+     * determine that. If no best row count is found, return null.
      */
-    public static GridDimension findBestRowCount(List<GridDimension> list, Info displayInfo) {
+    private static GridDimension findBestRowCount(List<GridDimension> list, int minWidthDp,
+            int minHeightDp) {
+        GridDimension selectedRow = null;
+        for (GridDimension item: list) {
+            if (minWidthDp >= item.mMinDeviceWidthDp && minHeightDp >= item.mMinDeviceHeightDp) {
+                if (selectedRow == null || selectedRow.mNumGridDimension < item.mNumGridDimension) {
+                    selectedRow = item;
+                }
+            }
+        }
+        return selectedRow;
+    }
+
+    private static int[] findMinWidthAndHeightDpForDevice(Info displayInfo) {
         int minWidthPx = Integer.MAX_VALUE;
         int minHeightPx = Integer.MAX_VALUE;
         for (WindowBounds bounds : displayInfo.supportedBounds) {
             boolean isTablet = displayInfo.isTablet(bounds);
             if (isTablet && displayInfo.getDeviceType() == TYPE_MULTI_DISPLAY) {
-                // For split displays, take half width per page
+                // For split displays, take half width per page.
                 minWidthPx = Math.min(minWidthPx, bounds.availableSize.x / 2);
                 minHeightPx = Math.min(minHeightPx, bounds.availableSize.y);
             } else if (!isTablet && bounds.isLandscape()) {
-                // We will use transposed layout in this case
+                // We will use transposed layout in this case.
                 minWidthPx = Math.min(minWidthPx, bounds.availableSize.y);
                 minHeightPx = Math.min(minHeightPx, bounds.availableSize.x);
             } else {
@@ -700,18 +716,10 @@
             }
         }
 
-        GridDimension selectedRow = null;
-        for (GridDimension item: list) {
-            if (minWidthPx >= item.mMinDeviceWidthPx && minHeightPx >= item.mMinDeviceHeightPx) {
-                if (selectedRow == null || selectedRow.mNumGridDimension < item.mNumGridDimension) {
-                    selectedRow = item;
-                }
-            }
-        }
-        if (selectedRow != null) {
-            return selectedRow;
-        }
-        return null;
+        int minWidthDp = (int) dpiFromPx(minWidthPx, DisplayMetrics.DENSITY_DEVICE_STABLE);
+        int minHeightDp = (int) dpiFromPx(minHeightPx, DisplayMetrics.DENSITY_DEVICE_STABLE);
+
+        return new int[]{minWidthDp, minHeightDp};
     }
 
     /**
@@ -1237,8 +1245,8 @@
 
     public static final class GridDimension {
         final int mNumGridDimension;
-        final float mMinDeviceWidthPx;
-        final float mMinDeviceHeightPx;
+        final int mMinDeviceWidthDp;
+        final int mMinDeviceHeightDp;
         final String mDbFile;
         final int mDefaultLayoutId;
         final int mDemoModeLayoutId;
@@ -1248,8 +1256,8 @@
             TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.GridDimension);
 
             mNumGridDimension = (int) a.getFloat(R.styleable.GridDimension_numGridDimension, 0);
-            mMinDeviceWidthPx = a.getFloat(R.styleable.GridDimension_minDeviceWidthPx, 0);
-            mMinDeviceHeightPx = a.getFloat(R.styleable.GridDimension_minDeviceHeightPx, 0);
+            mMinDeviceWidthDp = a.getInt(R.styleable.GridDimension_minDeviceWidthDp, 0);
+            mMinDeviceHeightDp = a.getInt(R.styleable.GridDimension_minDeviceHeightDp, 0);
             mDbFile = a.getString(R.styleable.GridDimension_dbFile);
             mDefaultLayoutId = a.getResourceId(
                     R.styleable.GridDimension_defaultLayoutId, 0);
diff --git a/src/com/android/launcher3/Workspace.java b/src/com/android/launcher3/Workspace.java
index 95dbf5f..69a5a83 100644
--- a/src/com/android/launcher3/Workspace.java
+++ b/src/com/android/launcher3/Workspace.java
@@ -116,6 +116,7 @@
 import com.android.launcher3.util.IntSet;
 import com.android.launcher3.util.IntSparseArrayMap;
 import com.android.launcher3.util.LauncherBindableItemsContainer;
+import com.android.launcher3.util.MSDLPlayerWrapper;
 import com.android.launcher3.util.OverlayEdgeEffect;
 import com.android.launcher3.util.PackageUserKey;
 import com.android.launcher3.util.RunnableList;
@@ -133,6 +134,8 @@
 import com.android.systemui.plugins.shared.LauncherOverlayManager.LauncherOverlayCallbacks;
 import com.android.systemui.plugins.shared.LauncherOverlayManager.LauncherOverlayTouchProxy;
 
+import com.google.android.msdl.data.model.MSDLToken;
+
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
@@ -299,6 +302,8 @@
 
     private final StatsLogManager mStatsLogManager;
 
+    private final MSDLPlayerWrapper mMSDLPlayerWrapper;
+
     /**
      * Used to inflate the Workspace from XML.
      *
@@ -331,6 +336,7 @@
         setMotionEventSplittingEnabled(true);
         setOnTouchListener(new WorkspaceTouchListener(mLauncher, this));
         mStatsLogManager = StatsLogManager.newInstance(context);
+        mMSDLPlayerWrapper = MSDLPlayerWrapper.INSTANCE.get(context);
     }
 
     @Override
@@ -2679,7 +2685,9 @@
         ItemInfo info = dragObject.dragInfo;
         boolean userFolderPending = willCreateUserFolder(info, mDragOverView, false);
         if (mDragMode == DRAG_MODE_NONE && userFolderPending) {
-
+            if (Flags.msdlFeedback()) {
+                mMSDLPlayerWrapper.playToken(MSDLToken.DRAG_INDICATOR_DISCRETE);
+            }
             mFolderCreateBg = new PreviewBackground(getContext());
             mFolderCreateBg.setup(mLauncher, mLauncher, null,
                     mDragOverView.getMeasuredWidth(), mDragOverView.getPaddingTop());
diff --git a/src/com/android/launcher3/allapps/AllAppsGridAdapter.java b/src/com/android/launcher3/allapps/AllAppsGridAdapter.java
index df383bf..b6ba264 100644
--- a/src/com/android/launcher3/allapps/AllAppsGridAdapter.java
+++ b/src/com/android/launcher3/allapps/AllAppsGridAdapter.java
@@ -125,6 +125,12 @@
         }
 
         @Override
+        public int getColumnCountForAccessibility(RecyclerView.Recycler recycler,
+                RecyclerView.State state) {
+            return mAppsPerRow;
+        }
+
+        @Override
         public void onInitializeAccessibilityNodeInfoForItem(RecyclerView.Recycler recycler,
                 RecyclerView.State state, View host, AccessibilityNodeInfoCompat info) {
             super.onInitializeAccessibilityNodeInfoForItem(recycler, state, host, info);
diff --git a/src/com/android/launcher3/backuprestore/LauncherRestoreEventLogger.kt b/src/com/android/launcher3/backuprestore/LauncherRestoreEventLogger.kt
index b05539a..1502811 100644
--- a/src/com/android/launcher3/backuprestore/LauncherRestoreEventLogger.kt
+++ b/src/com/android/launcher3/backuprestore/LauncherRestoreEventLogger.kt
@@ -16,11 +16,16 @@
     @Retention(AnnotationRetention.SOURCE)
     @StringDef(
         RestoreError.PROFILE_DELETED,
-        RestoreError.MISSING_INFO,
         RestoreError.MISSING_WIDGET_PROVIDER,
-        RestoreError.INVALID_LOCATION,
+        RestoreError.OVERLAPPING_ITEM,
+        RestoreError.INVALID_WIDGET_SIZE,
+        RestoreError.INVALID_WIDGET_CONTAINER,
         RestoreError.SHORTCUT_NOT_FOUND,
-        RestoreError.APP_NOT_INSTALLED,
+        RestoreError.APP_NO_TARGET_PACKAGE,
+        RestoreError.APP_NO_DB_INTENT,
+        RestoreError.APP_NO_LAUNCH_INTENT,
+        RestoreError.APP_NOT_RESTORED_OR_INSTALLING,
+        RestoreError.APP_NOT_INSTALLED_EXTERNAL_MEDIA,
         RestoreError.WIDGETS_DISABLED,
         RestoreError.PROFILE_NOT_RESTORED,
         RestoreError.WIDGET_REMOVED,
@@ -28,15 +33,24 @@
         RestoreError.GRID_MIGRATION_FAILURE,
         RestoreError.NO_SEARCH_WIDGET,
         RestoreError.INVALID_WIDGET_ID,
+        RestoreError.OTHER_WIDGET_INFLATION_FAIL,
+        RestoreError.UNSPECIFIED_WIDGET_INFLATION_RESULT,
+        RestoreError.UNRESTORED_PENDING_WIDGET,
+        RestoreError.INVALID_CUSTOM_WIDGET_ID,
     )
     annotation class RestoreError {
         companion object {
             const val PROFILE_DELETED = "user_profile_deleted"
-            const val MISSING_INFO = "missing_information_when_loading"
             const val MISSING_WIDGET_PROVIDER = "missing_widget_provider"
-            const val INVALID_LOCATION = "invalid_size_or_location"
+            const val OVERLAPPING_ITEM = "overlapping_item"
+            const val INVALID_WIDGET_SIZE = "invalid_widget_size"
+            const val INVALID_WIDGET_CONTAINER = "invalid_widget_container"
             const val SHORTCUT_NOT_FOUND = "shortcut_not_found"
-            const val APP_NOT_INSTALLED = "app_not_installed"
+            const val APP_NO_TARGET_PACKAGE = "app_no_target_package"
+            const val APP_NO_DB_INTENT = "app_no_db_intent"
+            const val APP_NO_LAUNCH_INTENT = "app_no_launch_intent"
+            const val APP_NOT_RESTORED_OR_INSTALLING = "app_not_restored_or_installed"
+            const val APP_NOT_INSTALLED_EXTERNAL_MEDIA = "app_not_installed_external_media"
             const val WIDGETS_DISABLED = "widgets_disabled"
             const val PROFILE_NOT_RESTORED = "profile_not_restored"
             const val DATABASE_FILE_NOT_RESTORED = "db_file_not_restored"
@@ -44,6 +58,10 @@
             const val GRID_MIGRATION_FAILURE = "grid_migration_failed"
             const val NO_SEARCH_WIDGET = "no_search_widget"
             const val INVALID_WIDGET_ID = "invalid_widget_id"
+            const val OTHER_WIDGET_INFLATION_FAIL = "other_widget_fail"
+            const val UNSPECIFIED_WIDGET_INFLATION_RESULT = "unspecified_widget_inflation_result"
+            const val UNRESTORED_PENDING_WIDGET = "unrestored_pending_widget"
+            const val INVALID_CUSTOM_WIDGET_ID = "invalid_custom_widget_id"
         }
     }
 
diff --git a/src/com/android/launcher3/model/LoaderCursor.java b/src/com/android/launcher3/model/LoaderCursor.java
index 84130c7..c01b1b6 100644
--- a/src/com/android/launcher3/model/LoaderCursor.java
+++ b/src/com/android/launcher3/model/LoaderCursor.java
@@ -498,7 +498,7 @@
                 mRestoreEventLogger.logSingleFavoritesItemRestored(itemType);
             }
         } else {
-            markDeleted("Item position overlap", RestoreError.INVALID_LOCATION);
+            markDeleted("Item position overlap", RestoreError.OVERLAPPING_ITEM);
         }
     }
 
diff --git a/src/com/android/launcher3/model/WorkspaceItemProcessor.kt b/src/com/android/launcher3/model/WorkspaceItemProcessor.kt
index c02336e..e86b592 100644
--- a/src/com/android/launcher3/model/WorkspaceItemProcessor.kt
+++ b/src/com/android/launcher3/model/WorkspaceItemProcessor.kt
@@ -141,7 +141,7 @@
         var allowMissingTarget = false
         var intent = c.parseIntent()
         if (intent == null) {
-            c.markDeleted("Null intent from db for item id=${c.id}", RestoreError.MISSING_INFO)
+            c.markDeleted("Null intent from db for item id=${c.id}", RestoreError.APP_NO_DB_INTENT)
             return
         }
         var disabledState =
@@ -151,7 +151,10 @@
         val cn = intent.component
         val targetPkg = cn?.packageName ?: intent.getPackage()
         if (targetPkg.isNullOrEmpty()) {
-            c.markDeleted("No target package for item id=${c.id}", RestoreError.MISSING_INFO)
+            c.markDeleted(
+                "No target package for item id=${c.id}",
+                RestoreError.APP_NO_TARGET_PACKAGE,
+            )
             return
         }
         val appInfoWrapper = ApplicationInfoWrapper(app.context, targetPkg, c.user)
@@ -180,7 +183,7 @@
                     c.markDeleted(
                         "No Activities found for id=${c.id}, targetPkg=$targetPkg, component=$cn." +
                             " Unable to create launch Intent.",
-                        RestoreError.MISSING_INFO,
+                        RestoreError.APP_NO_LAUNCH_INTENT,
                     )
                     return
                 }
@@ -215,7 +218,7 @@
                             else -> {
                                 c.markDeleted(
                                     "removing app that is not restored and not installing. package: $targetPkg",
-                                    RestoreError.APP_NOT_INSTALLED,
+                                    RestoreError.APP_NOT_RESTORED_OR_INSTALLING,
                                 )
                                 return
                             }
@@ -240,7 +243,7 @@
                         // Do not wait for external media load anymore.
                         c.markDeleted(
                             "Invalid package removed: $targetPkg",
-                            RestoreError.APP_NOT_INSTALLED,
+                            RestoreError.APP_NOT_INSTALLED_EXTERNAL_MEDIA,
                         )
                         return
                     }
@@ -448,7 +451,7 @@
                     ", id=${c.id}," +
                     ", appWidgetId=${c.appWidgetId}," +
                     ", component=${component}",
-                RestoreError.INVALID_LOCATION,
+                RestoreError.INVALID_WIDGET_SIZE,
             )
             return
         }
@@ -459,7 +462,7 @@
                     ", appWidgetId=${c.appWidgetId}," +
                     ", component=${component}," +
                     ", container=${c.container}",
-                RestoreError.INVALID_LOCATION,
+                RestoreError.INVALID_WIDGET_CONTAINER,
             )
             return
         }
@@ -500,7 +503,7 @@
                             ", appWidgetId=${c.appWidgetId}" +
                             ", component=${component}" +
                             ", restoreFlag:=${c.restoreFlag}",
-                        RestoreError.APP_NOT_INSTALLED,
+                        RestoreError.UNRESTORED_PENDING_WIDGET,
                     )
                     return
                 } else if (
diff --git a/src/com/android/launcher3/widget/WidgetInflater.kt b/src/com/android/launcher3/widget/WidgetInflater.kt
index 271c9c2..d6cadc7 100644
--- a/src/com/android/launcher3/widget/WidgetInflater.kt
+++ b/src/com/android/launcher3/widget/WidgetInflater.kt
@@ -30,16 +30,14 @@
 
     private val widgetHelper = WidgetManagerHelper(context)
 
-    fun inflateAppWidget(
-        item: LauncherAppWidgetInfo,
-    ): InflationResult {
+    fun inflateAppWidget(item: LauncherAppWidgetInfo): InflationResult {
         if (item.hasOptionFlag(LauncherAppWidgetInfo.OPTION_SEARCH_WIDGET)) {
             item.providerName = QsbContainerView.getSearchComponentName(context)
             if (item.providerName == null) {
                 return InflationResult(
                     TYPE_DELETE,
                     reason = "search widget removed because search component cannot be found",
-                    restoreErrorType = RestoreError.NO_SEARCH_WIDGET
+                    restoreErrorType = RestoreError.NO_SEARCH_WIDGET,
                 )
             }
         }
@@ -48,7 +46,7 @@
         }
         val appWidgetInfo: LauncherAppWidgetProviderInfo?
         var removalReason = ""
-        @RestoreError var logReason = RestoreError.APP_NOT_INSTALLED
+        @RestoreError var logReason = RestoreError.OTHER_WIDGET_INFLATION_FAIL
         var update = false
 
         if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_NOT_VALID)) {
@@ -74,7 +72,7 @@
             if (appWidgetInfo == null) {
                 if (item.appWidgetId <= LauncherAppWidgetInfo.CUSTOM_WIDGET_ID) {
                     removalReason = "CustomWidgetManager cannot find provider from that widget id."
-                    logReason = RestoreError.MISSING_INFO
+                    logReason = RestoreError.INVALID_CUSTOM_WIDGET_ID
                 } else {
                     removalReason =
                         ("AppWidgetManager cannot find provider for that widget id." +
@@ -96,7 +94,7 @@
                     type = TYPE_DELETE,
                     reason =
                         "Removing restored widget: id=${item.appWidgetId} belongs to component ${item.providerName} user ${item.user}, as the provider is null and $removalReason",
-                    restoreErrorType = logReason
+                    restoreErrorType = logReason,
                 )
             }
 
@@ -132,7 +130,7 @@
                         widgetHelper.bindAppWidgetIdIfAllowed(
                             item.appWidgetId,
                             appWidgetInfo,
-                            options
+                            options,
                         )
 
                     // We tried to bind once. If we were not able to bind, we would need to
@@ -189,9 +187,10 @@
     data class InflationResult(
         val type: Int,
         val reason: String? = null,
-        @RestoreError val restoreErrorType: String = RestoreError.APP_NOT_INSTALLED,
+        @RestoreError
+        val restoreErrorType: String = RestoreError.UNSPECIFIED_WIDGET_INFLATION_RESULT,
         val isUpdate: Boolean = false,
-        val widgetInfo: LauncherAppWidgetProviderInfo? = null
+        val widgetInfo: LauncherAppWidgetProviderInfo? = null,
     )
 
     companion object {
diff --git a/tests/multivalentTests/src/com/android/launcher3/model/WorkspaceItemProcessorTest.kt b/tests/multivalentTests/src/com/android/launcher3/model/WorkspaceItemProcessorTest.kt
index ed8b397..7099d38 100644
--- a/tests/multivalentTests/src/com/android/launcher3/model/WorkspaceItemProcessorTest.kt
+++ b/tests/multivalentTests/src/com/android/launcher3/model/WorkspaceItemProcessorTest.kt
@@ -36,10 +36,7 @@
 import com.android.launcher3.LauncherSettings.Favorites.ITEM_TYPE_DEEP_SHORTCUT
 import com.android.launcher3.LauncherSettings.Favorites.ITEM_TYPE_FOLDER
 import com.android.launcher3.Utilities.EMPTY_PERSON_ARRAY
-import com.android.launcher3.backuprestore.LauncherRestoreEventLogger
-import com.android.launcher3.backuprestore.LauncherRestoreEventLogger.RestoreError.Companion.MISSING_INFO
-import com.android.launcher3.backuprestore.LauncherRestoreEventLogger.RestoreError.Companion.MISSING_WIDGET_PROVIDER
-import com.android.launcher3.backuprestore.LauncherRestoreEventLogger.RestoreError.Companion.PROFILE_DELETED
+import com.android.launcher3.backuprestore.LauncherRestoreEventLogger.RestoreError
 import com.android.launcher3.icons.CacheableShortcutInfo
 import com.android.launcher3.model.data.FolderInfo
 import com.android.launcher3.model.data.IconRequestInfo
@@ -224,7 +221,8 @@
         itemProcessorUnderTest.processItem()
 
         // Then
-        verify(mockCursor).markDeleted("User has been deleted for item id=1", PROFILE_DELETED)
+        verify(mockCursor)
+            .markDeleted("User has been deleted for item id=1", RestoreError.PROFILE_DELETED)
         verify(mockCursor, times(0)).checkAndAddItem(any(), any(), anyOrNull())
     }
 
@@ -237,7 +235,8 @@
         itemProcessorUnderTest = createWorkspaceItemProcessorUnderTest()
         itemProcessorUnderTest.processItem()
         // Then
-        verify(mockCursor).markDeleted("Null intent from db for item id=1", MISSING_INFO)
+        verify(mockCursor)
+            .markDeleted("Null intent from db for item id=1", RestoreError.APP_NO_DB_INTENT)
         verify(mockCursor, times(0)).checkAndAddItem(any(), any(), anyOrNull())
     }
 
@@ -255,7 +254,8 @@
         itemProcessorUnderTest.processItem()
 
         // Then
-        verify(mockCursor).markDeleted("No target package for item id=1", MISSING_INFO)
+        verify(mockCursor)
+            .markDeleted("No target package for item id=1", RestoreError.APP_NO_TARGET_PACKAGE)
         verify(mockCursor, times(0)).checkAndAddItem(any(), any(), anyOrNull())
     }
 
@@ -272,7 +272,8 @@
         itemProcessorUnderTest.processItem()
 
         // Then
-        verify(mockCursor).markDeleted("No target package for item id=1", MISSING_INFO)
+        verify(mockCursor)
+            .markDeleted("No target package for item id=1", RestoreError.APP_NO_TARGET_PACKAGE)
         verify(mockCursor, times(0)).checkAndAddItem(any(), any(), anyOrNull())
     }
 
@@ -350,7 +351,7 @@
                     " targetPkg=package," +
                     " component=ComponentInfo{package/class}." +
                     " Unable to create launch Intent.",
-                MISSING_INFO,
+                RestoreError.APP_NO_LAUNCH_INTENT,
             )
         verify(mockCursor, times(0)).checkAndAddItem(any(), any(), anyOrNull())
     }
@@ -663,7 +664,7 @@
         verify(mockCursor)
             .markDeleted(
                 "processWidget: Unrestored Pending widget removed: id=1, appWidgetId=0, component=$expectedComponentName, restoreFlag:=4",
-                LauncherRestoreEventLogger.RestoreError.APP_NOT_INSTALLED,
+                RestoreError.UNRESTORED_PENDING_WIDGET,
             )
     }
 
@@ -689,7 +690,7 @@
                 type = WidgetInflater.TYPE_DELETE,
                 widgetInfo = null,
                 reason = "test_delete_reason",
-                restoreErrorType = MISSING_WIDGET_PROVIDER,
+                restoreErrorType = RestoreError.MISSING_WIDGET_PROVIDER,
             )
         mockWidgetInflater =
             mock<WidgetInflater>().apply {
