diff --git a/Android.bp b/Android.bp
index 85632b2..2c4fb37 100644
--- a/Android.bp
+++ b/Android.bp
@@ -409,6 +409,9 @@
     lint: {
         baseline_filename: "lint-baseline.xml",
     },
+    flags_packages: [
+        "com_android_launcher3_flags",
+    ],
 }
 
 //
diff --git a/PREUPLOAD.cfg b/PREUPLOAD.cfg
index 6948133..768ba65 100644
--- a/PREUPLOAD.cfg
+++ b/PREUPLOAD.cfg
@@ -1,8 +1,10 @@
 [Builtin Hooks]
 ktfmt = true
+bpfmt = true
 
 [Builtin Hooks Options]
 ktfmt = --kotlinlang-style
+bpfmt = -d
 
 [Tool Paths]
 ktfmt = ${REPO_ROOT}/external/ktfmt/ktfmt.sh
diff --git a/aconfig/launcher.aconfig b/aconfig/launcher.aconfig
index c5774bb..d3c5c01 100644
--- a/aconfig/launcher.aconfig
+++ b/aconfig/launcher.aconfig
@@ -311,6 +311,13 @@
 }
 
 flag {
+    name: "all_apps_blur"
+    namespace: "launcher"
+    description: "Content behind the all apps panel in Launcher will be blurred."
+    bug: "400827727"
+}
+
+flag {
     name: "multiline_search_bar"
     namespace: "launcher"
     description: "Search bar can wrap to multi-line"
@@ -559,6 +566,17 @@
 }
 
 flag {
+  name: "gsf_res"
+  namespace: "launcher"
+  description: "Adds refresh for font family. Needs to be fixed to be used in resources."
+  bug: "395145453"
+  is_fixed_read_only: true
+  metadata {
+    purpose: PURPOSE_BUGFIX
+  }
+}
+
+flag {
   name: "restore_archived_shortcuts"
   namespace: "launcher"
   description: "Makes sure pre-archived pinned shortcuts also get restored"
@@ -656,3 +674,23 @@
     purpose: PURPOSE_BUGFIX
   }
 }
+
+flag {
+  name: "sync_app_launch_with_taskbar_stash"
+  namespace: "launcher"
+  description: "Syncs the two animations (app launch, taskbar stash) so they play at the same time."
+  bug: "319162553"
+  metadata {
+    purpose: PURPOSE_BUGFIX
+  }
+}
+
+flag {
+  name: "remove_apps_refresh_on_right_click"
+  namespace: "launcher"
+  description: "Remove predicted apps refresh on right click"
+  bug: "343650193"
+  metadata {
+    purpose: PURPOSE_BUGFIX
+  }
+}
diff --git a/proguard.flags b/proguard.flags
index da00c00..c0a0042 100644
--- a/proguard.flags
+++ b/proguard.flags
@@ -1,6 +1,12 @@
--keep,allowshrinking,allowoptimization class com.android.launcher3.** {
-  *;
-}
+
+-keep,allowshrinking,allowoptimization class com.android.launcher3.** {*;}
+-keepclasseswithmembernames class com.android.launcher3.** {*;}
+
+-keep,allowshrinking,allowoptimization class com.android.systemui.shared.** {*;}
+-keepclasseswithmembernames class com.android.systemui.shared.** {*;}
+
+-keep,allowshrinking,allowoptimization class com.android.quickstep.** {*;}
+-keepclasseswithmembernames class com.android.quickstep.** {*;}
 
 # The support library contains references to newer platform versions.
 # Don't warn about those in case this app is linking against an older
@@ -49,14 +55,6 @@
 # Ignore warnings for hidden utility classes referenced from the shared lib
 -dontwarn com.android.internal.util.**
 
-################ Do not optimize recents lib #############
--keep class com.android.systemui.shared.** {
-  *;
-}
-
--keep class com.android.quickstep.** {
-  *;
-}
 
 -keep class com.android.internal.protolog.** {
   *;
diff --git a/quickstep/res/color/app_chip_menu_item_color_fg.xml b/quickstep/res/color/app_chip_menu_item_color_fg.xml
new file mode 100644
index 0000000..fa1dc34
--- /dev/null
+++ b/quickstep/res/color/app_chip_menu_item_color_fg.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2025 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.
+  -->
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:alpha="0.15" android:color="@color/materialColorOnSurface" android:state_enabled="true" android:state_pressed="true" />
+    <item android:alpha="0.11" android:color="@color/materialColorOnSurface" android:state_enabled="true" android:state_hovered="true" />
+    <item android:color="@android:color/transparent" />
+</selector>
\ No newline at end of file
diff --git a/quickstep/res/color/app_chip_state_color_fg.xml b/quickstep/res/color/app_chip_state_color_fg.xml
new file mode 100644
index 0000000..58dfee0
--- /dev/null
+++ b/quickstep/res/color/app_chip_state_color_fg.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?><!--
+  ~ Copyright (C) 2025 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.
+  -->
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:alpha="0.15" android:color="@color/materialColorOnSurface" android:state_enabled="true" android:state_pressed="true" />
+    <item android:alpha="0.11" android:color="@color/materialColorOnSurface" android:state_enabled="true" android:state_hovered="true" />
+    <item android:color="@android:color/transparent" />
+</selector>
\ No newline at end of file
diff --git a/quickstep/res/drawable/app_chip_fg.xml b/quickstep/res/drawable/app_chip_fg.xml
new file mode 100644
index 0000000..7b19c9e
--- /dev/null
+++ b/quickstep/res/drawable/app_chip_fg.xml
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?><!--
+  ~ Copyright (C) 2025 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.
+  -->
+<shape xmlns:android="http://schemas.android.com/apk/res/android">
+    <solid android:color="@color/app_chip_state_color_fg" />
+</shape>
\ No newline at end of file
diff --git a/quickstep/res/drawable/app_chip_menu_item_bg.xml b/quickstep/res/drawable/app_chip_menu_item_bg.xml
new file mode 100644
index 0000000..39e88d2
--- /dev/null
+++ b/quickstep/res/drawable/app_chip_menu_item_bg.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2025 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.
+  -->
+<shape xmlns:android="http://schemas.android.com/apk/res/android">
+    <solid android:color="@color/materialColorSurfaceBright" />
+</shape>
diff --git a/quickstep/res/drawable/app_chip_menu_item_fg.xml b/quickstep/res/drawable/app_chip_menu_item_fg.xml
new file mode 100644
index 0000000..96d067d
--- /dev/null
+++ b/quickstep/res/drawable/app_chip_menu_item_fg.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2025 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.
+  -->
+<shape xmlns:android="http://schemas.android.com/apk/res/android">
+    <solid android:color="@color/app_chip_menu_item_color_fg" />
+    <corners android:radius="@dimen/task_menu_item_corner_radius" />
+</shape>
diff --git a/quickstep/res/drawable/taskbar_divider_button_expressive_theme.xml b/quickstep/res/drawable/taskbar_divider_button_expressive_theme.xml
new file mode 100644
index 0000000..7fc61fc
--- /dev/null
+++ b/quickstep/res/drawable/taskbar_divider_button_expressive_theme.xml
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2025 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.
+-->
+
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="52dp"
+    android:height="52dp"
+    android:viewportHeight="52"
+    android:viewportWidth="52">
+    <group>
+        <path
+            android:fillColor="@color/taskbar_divider_background"
+            android:pathData="M26,14L26,38"
+            android:strokeColor="@color/taskbar_divider_background"
+            android:strokeLineCap="round"
+            android:strokeWidth="3" />
+    </group>
+</vector>
\ No newline at end of file
diff --git a/quickstep/res/layout-land/keyboard_quick_switch_taskview.xml b/quickstep/res/layout-land/keyboard_quick_switch_taskview.xml
index b44510d..b45a04a 100644
--- a/quickstep/res/layout-land/keyboard_quick_switch_taskview.xml
+++ b/quickstep/res/layout-land/keyboard_quick_switch_taskview.xml
@@ -21,14 +21,14 @@
     android:layout_width="wrap_content"
     android:layout_height="wrap_content"
     android:importantForAccessibility="yes"
-    android:background="@drawable/keyboard_quick_switch_task_view_background"
-    android:clipToOutline="true"
-    launcher:focusBorderColor="@color/materialColorOutline">
+    launcher:focusBorderColor="@color/materialColorSecondary">
 
     <androidx.constraintlayout.widget.ConstraintLayout
         android:id="@+id/content"
         android:layout_width="@dimen/keyboard_quick_switch_taskview_width"
         android:layout_height="@dimen/keyboard_quick_switch_taskview_height"
+        android:background="@drawable/keyboard_quick_switch_task_view_background"
+        android:clipToOutline="true"
 
         app:layout_constraintTop_toTopOf="parent"
         app:layout_constraintBottom_toBottomOf="parent"
diff --git a/quickstep/res/layout-land/keyboard_quick_switch_taskview_square.xml b/quickstep/res/layout-land/keyboard_quick_switch_taskview_square.xml
index 56b1adf..672b715 100644
--- a/quickstep/res/layout-land/keyboard_quick_switch_taskview_square.xml
+++ b/quickstep/res/layout-land/keyboard_quick_switch_taskview_square.xml
@@ -21,14 +21,14 @@
     android:layout_width="wrap_content"
     android:layout_height="wrap_content"
     android:importantForAccessibility="yes"
-    android:background="@drawable/keyboard_quick_switch_task_view_background"
-    android:clipToOutline="true"
-    launcher:focusBorderColor="@androidprv:color/materialColorOutline">
+    launcher:focusBorderColor="@color/materialColorSecondary">
 
     <androidx.constraintlayout.widget.ConstraintLayout
         android:id="@+id/content"
         android:layout_width="0dp"
         android:layout_height="@dimen/keyboard_quick_switch_taskview_height"
+        android:background="@drawable/keyboard_quick_switch_task_view_background"
+        android:clipToOutline="true"
 
         app:layout_constraintDimensionRatio="1:1"
         app:layout_constraintTop_toTopOf="parent"
diff --git a/quickstep/res/layout/icon_app_chip_view.xml b/quickstep/res/layout/icon_app_chip_view.xml
index 0972be1..09fb509 100644
--- a/quickstep/res/layout/icon_app_chip_view.xml
+++ b/quickstep/res/layout/icon_app_chip_view.xml
@@ -22,10 +22,12 @@
     android:layout_width="@dimen/task_thumbnail_icon_menu_expanded_width"
     android:layout_height="@dimen/task_thumbnail_icon_menu_expanded_height"
     android:clipToOutline="true"
-    android:focusable="false"
+    android:focusable="true"
+    android:focusableInTouchMode="false"
     android:importantForAccessibility="no"
     android:autoMirrored="true"
     android:elevation="@dimen/task_thumbnail_icon_menu_elevation"
+    android:foreground="@drawable/app_chip_fg"
     android:background="@color/materialColorSurfaceBright">
 
     <!-- ignoring warning because the user of the anchor is a Rect where RTL is not needed -->
@@ -77,4 +79,5 @@
         android:background="@drawable/icon_menu_arrow_background"
         android:src="@drawable/ic_chevron_down"
         android:importantForAccessibility="no" />
+
 </com.android.quickstep.views.IconAppChipView>
\ No newline at end of file
diff --git a/quickstep/res/layout/keyboard_quick_switch_desktop_taskview.xml b/quickstep/res/layout/keyboard_quick_switch_desktop_taskview.xml
index db47ff0..d281732 100644
--- a/quickstep/res/layout/keyboard_quick_switch_desktop_taskview.xml
+++ b/quickstep/res/layout/keyboard_quick_switch_desktop_taskview.xml
@@ -20,9 +20,8 @@
     xmlns:launcher="http://schemas.android.com/apk/res-auto"
     android:layout_width="wrap_content"
     android:layout_height="wrap_content"
-    android:clipToOutline="true"
     android:importantForAccessibility="yes"
-    launcher:focusBorderColor="@androidprv:color/materialColorOutline"
+    launcher:focusBorderColor="@color/materialColorSecondary"
     launcher:focusBorderRadius="@dimen/keyboard_quick_switch_text_button_radius">
 
     <androidx.constraintlayout.widget.ConstraintLayout
@@ -31,6 +30,7 @@
         android:layout_height="@dimen/keyboard_quick_switch_taskview_height"
         android:background="@drawable/keyboard_quick_switch_text_button_background"
         android:backgroundTint="@androidprv:color/materialColorSurfaceContainer"
+        android:clipToOutline="true"
         android:paddingHorizontal="@dimen/keyboard_quick_switch_text_button_horizontal_padding"
 
         app:layout_constraintTop_toTopOf="parent"
diff --git a/quickstep/res/layout/keyboard_quick_switch_overview_taskview.xml b/quickstep/res/layout/keyboard_quick_switch_overview_taskview.xml
index 5a3ee83..3321306 100644
--- a/quickstep/res/layout/keyboard_quick_switch_overview_taskview.xml
+++ b/quickstep/res/layout/keyboard_quick_switch_overview_taskview.xml
@@ -20,9 +20,8 @@
     xmlns:launcher="http://schemas.android.com/apk/res-auto"
     android:layout_width="wrap_content"
     android:layout_height="wrap_content"
-    android:clipToOutline="true"
     android:importantForAccessibility="yes"
-    launcher:focusBorderColor="@androidprv:color/materialColorOutline"
+    launcher:focusBorderColor="@color/materialColorSecondary"
     launcher:focusBorderRadius="@dimen/keyboard_quick_switch_text_button_radius">
 
     <androidx.constraintlayout.widget.ConstraintLayout
@@ -31,6 +30,7 @@
         android:layout_height="@dimen/keyboard_quick_switch_taskview_height"
         android:background="@drawable/keyboard_quick_switch_text_button_background"
         android:backgroundTint="@androidprv:color/materialColorSurfaceBright"
+        android:clipToOutline="true"
         android:paddingHorizontal="@dimen/keyboard_quick_switch_text_button_horizontal_padding"
 
         app:layout_constraintTop_toTopOf="parent"
diff --git a/quickstep/res/layout/keyboard_quick_switch_taskview.xml b/quickstep/res/layout/keyboard_quick_switch_taskview.xml
index 37bb027..218a3f2 100644
--- a/quickstep/res/layout/keyboard_quick_switch_taskview.xml
+++ b/quickstep/res/layout/keyboard_quick_switch_taskview.xml
@@ -21,14 +21,14 @@
     android:layout_width="wrap_content"
     android:layout_height="wrap_content"
     android:importantForAccessibility="yes"
-    android:background="@drawable/keyboard_quick_switch_task_view_background"
-    android:clipToOutline="true"
-    launcher:focusBorderColor="@color/materialColorOutline">
+    launcher:focusBorderColor="@color/materialColorSecondary">
 
     <androidx.constraintlayout.widget.ConstraintLayout
         android:id="@+id/content"
         android:layout_width="@dimen/keyboard_quick_switch_taskview_width"
         android:layout_height="@dimen/keyboard_quick_switch_taskview_height"
+        android:background="@drawable/keyboard_quick_switch_task_view_background"
+        android:clipToOutline="true"
 
         app:layout_constraintTop_toTopOf="parent"
         app:layout_constraintBottom_toBottomOf="parent"
diff --git a/quickstep/res/layout/keyboard_quick_switch_taskview_square.xml b/quickstep/res/layout/keyboard_quick_switch_taskview_square.xml
index 33d8c16..d3f5bf1 100644
--- a/quickstep/res/layout/keyboard_quick_switch_taskview_square.xml
+++ b/quickstep/res/layout/keyboard_quick_switch_taskview_square.xml
@@ -21,14 +21,14 @@
     android:layout_width="wrap_content"
     android:layout_height="wrap_content"
     android:importantForAccessibility="yes"
-    android:background="@drawable/keyboard_quick_switch_task_view_background"
-    android:clipToOutline="true"
-    launcher:focusBorderColor="@androidprv:color/materialColorOutline">
+    launcher:focusBorderColor="@color/materialColorSecondary">
 
     <androidx.constraintlayout.widget.ConstraintLayout
         android:id="@+id/content"
         android:layout_width="0dp"
         android:layout_height="@dimen/keyboard_quick_switch_taskview_height"
+        android:background="@drawable/keyboard_quick_switch_task_view_background"
+        android:clipToOutline="true"
 
         app:layout_constraintDimensionRatio="1:1"
         app:layout_constraintTop_toTopOf="parent"
diff --git a/quickstep/res/layout/task_header_view.xml b/quickstep/res/layout/task_header_view.xml
index ea5c24e..849153f 100644
--- a/quickstep/res/layout/task_header_view.xml
+++ b/quickstep/res/layout/task_header_view.xml
@@ -15,52 +15,48 @@
 -->
 <com.android.quickstep.views.TaskHeaderView xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:id="@+id/task_header_view"
     android:layout_width="match_parent"
     android:layout_height="wrap_content"
-    android:id="@+id/task_header_view"
+    android:paddingTop="@dimen/task_thumbnail_header_padding_top_bottom"
+    android:paddingBottom="@dimen/task_thumbnail_header_padding_top_bottom"
+    android:paddingStart="@dimen/task_thumbnail_header_padding_start_end"
+    android:paddingEnd="@dimen/task_thumbnail_header_padding_start_end"
     android:background="@drawable/task_thumbnail_header_bg">
-
-    <androidx.constraintlayout.widget.ConstraintLayout
-        android:layout_width="match_parent"
-        android:layout_height="@dimen/task_thumbnail_header_height"
-        android:layout_marginStart="@dimen/task_thumbnail_header_margin_edge"
-        android:layout_marginEnd="@dimen/task_thumbnail_header_margin_edge"
+    <ImageView
+        android:id="@+id/header_app_icon"
+        android:layout_width="@dimen/task_thumbnail_header_icon_size"
+        android:layout_height="@dimen/task_thumbnail_header_icon_size"
+        android:layout_marginStart="@dimen/task_thumbnail_header_margin_between_views"
+        android:layout_marginEnd="@dimen/task_thumbnail_header_margin_between_views"
+        android:contentDescription="@string/header_app_icon_description"
+        app:layout_constraintBottom_toBottomOf="parent"
         app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintTop_toTopOf="parent" />
+    <TextView
+        android:id="@+id/header_app_title"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_marginStart="@dimen/task_thumbnail_header_margin_between_views"
+        android:layout_marginEnd="@dimen/task_thumbnail_header_margin_between_views"
+        android:maxLines="1"
+        android:text="@string/header_default_app_title"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintStart_toEndOf="@id/header_app_icon"
+        app:layout_constraintTop_toTopOf="parent" />
+    <ImageButton
+        android:id="@+id/header_close_button"
+        android:layout_width="@dimen/task_thumbnail_header_icon_size"
+        android:layout_height="@dimen/task_thumbnail_header_icon_size"
+        android:layout_marginStart="@dimen/task_thumbnail_header_margin_between_views"
+        android:layout_marginEnd="@dimen/task_thumbnail_header_margin_between_views"
+        android:background="@null"
+        android:contentDescription="@string/header_close_icon_description"
+        android:src="@drawable/task_header_close_button"
+        android:tint="@android:color/darker_gray"
+        app:layout_constraintBottom_toBottomOf="parent"
         app:layout_constraintEnd_toEndOf="parent"
-        app:layout_constraintTop_toTopOf="parent">
-        <ImageView
-            android:id="@+id/header_app_icon"
-            android:contentDescription="@string/header_app_icon_description"
-            android:layout_width="@dimen/task_thumbnail_header_icon_size"
-            android:layout_height="@dimen/task_thumbnail_header_icon_size"
-            android:layout_marginEnd="@dimen/task_thumbnail_header_margin_between_views"
-            app:layout_constraintStart_toStartOf="parent"
-            app:layout_constraintEnd_toStartOf="@id/header_app_title"
-            app:layout_constraintTop_toTopOf="parent"
-            app:layout_constraintBottom_toBottomOf="parent" />
-        <TextView
-            android:id="@+id/header_app_title"
-            android:layout_width="wrap_content"
-            android:layout_height="wrap_content"
-            android:layout_marginStart="@dimen/task_thumbnail_header_margin_between_views"
-            android:maxLines="1"
-            android:text="@string/header_default_app_title"
-            app:layout_constraintBottom_toBottomOf="parent"
-            app:layout_constraintStart_toEndOf="@id/header_app_icon"
-            app:layout_constraintTop_toTopOf="parent" />
-        <ImageButton
-            android:id="@+id/header_close_button"
-            android:contentDescription="@string/header_close_icon_description"
-            android:layout_width="@dimen/task_thumbnail_header_icon_size"
-            android:layout_height="@dimen/task_thumbnail_header_icon_size"
-            android:layout_marginStart="@dimen/task_thumbnail_header_margin_between_views"
-            android:src="@drawable/task_header_close_button"
-            android:tint="@android:color/darker_gray"
-            android:background="@null"
-            app:layout_constraintEnd_toEndOf="parent"
-            app:layout_constraintTop_toTopOf="parent"
-            app:layout_constraintBottom_toBottomOf="parent"
-            app:layout_constraintStart_toEndOf="@id/header_app_title"
-            app:layout_constraintHorizontal_bias="1" />
-    </androidx.constraintlayout.widget.ConstraintLayout>
+        app:layout_constraintHorizontal_bias="1"
+        app:layout_constraintStart_toEndOf="@id/header_app_title"
+        app:layout_constraintTop_toTopOf="parent" />
 </com.android.quickstep.views.TaskHeaderView>
diff --git a/quickstep/res/values-af/strings.xml b/quickstep/res/values-af/strings.xml
index 7a6435b..c2f572b 100644
--- a/quickstep/res/values-af/strings.xml
+++ b/quickstep/res/values-af/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Taakbalkoorloop"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Skuif na links bo"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Skuif na regs onder"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Maak app as ’n borrel oop"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{meer app}other{meer apps}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Werkskerm"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> en <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Borrel"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Oorvloei"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> vanaf <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Appikoon"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Apptitel"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Maak Toe-knoppie"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Speld aan taakbalk vas"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Ontspeld van taakbalk"</string>
 </resources>
diff --git a/quickstep/res/values-am/strings.xml b/quickstep/res/values-am/strings.xml
index 7286f3f..e335423 100644
--- a/quickstep/res/values-am/strings.xml
+++ b/quickstep/res/values-am/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"የተግባር አሞሌ ትርፍ ፍሰት"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"ወደ ላይ/ግራ ይውሰዱ"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"ወደ ታች/ቀኝ ይውሰዱ"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"መተግበሪያን እንደ ዓረፋ ይክፈቱ"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{ተጨማሪ መተግበሪያ}one{ተጨማሪ መተግበሪያ}other{ተጨማሪ መተግበሪያዎች}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"ዴስክቶፕ"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> እና <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"አረፋ"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"ትርፍ ፍሰት"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> ከ<xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"የመተግበሪያ አዶ"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"የመተግበሪያ ርዕስ"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"የዝጋ አዝራር"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"ተግባር አሞሌ ላይ ፒን አድርግ"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"ከተግባር አሞሌ ንቀል"</string>
 </resources>
diff --git a/quickstep/res/values-ar/strings.xml b/quickstep/res/values-ar/strings.xml
index e673ac6..8fbc23b 100644
--- a/quickstep/res/values-ar/strings.xml
+++ b/quickstep/res/values-ar/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"القائمة الكاملة لشريط التطبيقات"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"الانتقال إلى يمين الشاشة أو أعلاها"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"الانتقال إلى يسار الشاشة أو أسفلها"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"فتح التطبيق كفقاعة"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{تطبيق واحد آخر}zero{تطبيق آخر}two{تطبيقان آخران}few{تطبيقات أخرى}many{تطبيقًا آخر}other{تطبيق آخر}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"وضع الكمبيوتر المكتبي"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"\"<xliff:g id="APP_NAME_1">%1$s</xliff:g>\" و\"<xliff:g id="APP_NAME_2">%2$s</xliff:g>\""</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"فقاعة"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"القائمة الكاملة"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"‫\"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g>\" من \"<xliff:g id="APP_NAME">%2$s</xliff:g>\""</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"رمز التطبيق"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"عنوان التطبيق"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"زر الإغلاق"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"التثبيت على شريط التطبيقات"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"إزالة التثبيت من شريط التطبيقات"</string>
 </resources>
diff --git a/quickstep/res/values-as/strings.xml b/quickstep/res/values-as/strings.xml
index 4f3c22d..8c1ccda 100644
--- a/quickstep/res/values-as/strings.xml
+++ b/quickstep/res/values-as/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"টাস্কবাৰ অ’ভাৰফ্ল"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"ওপৰৰ বাঁওফাললৈ নিয়ক"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"তলৰ সোঁফাললৈ নিয়ক"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"বাবল হিচাপে এপ্‌টো খোলক"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{অধিক এপ্‌}one{অধিক এপ্‌}other{অধিক এপ্‌}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"ডেস্কটপ"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> আৰু <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"বাবল"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"অ’ভাৰফ্ল’"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="APP_NAME">%2$s</xliff:g>ৰ পৰা <xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"এপৰ আইকন"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"এপৰ শিৰোনাম"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"বন্ধ কৰা বুটাম"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"টাস্কবাৰত পিন কৰক"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"টাস্কবাৰৰ পৰা আনপিন কৰক"</string>
 </resources>
diff --git a/quickstep/res/values-az/strings.xml b/quickstep/res/values-az/strings.xml
index f7f22e2..53de211 100644
--- a/quickstep/res/values-az/strings.xml
+++ b/quickstep/res/values-az/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Tapşırıqlar Paneli üzrə əlavə menyu"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Yuxarı/sola köçürün"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Aşağı/sağa köçürün"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Tətbiqi yumrucuq kimi açın"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{əlavə tətbiq}other{əlavə tətbiq}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Masaüstü"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> və <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Yumrucuq"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Kənara çıxma"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g>, <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Tətbiq ikonası"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Tətbiq başlığı"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Qapatma düyməsi"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"İşləmə panelinə bərkidin"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"İşləmə panelindən çıxarın"</string>
 </resources>
diff --git a/quickstep/res/values-b+sr+Latn/strings.xml b/quickstep/res/values-b+sr+Latn/strings.xml
index 67ecbcd..1db58be 100644
--- a/quickstep/res/values-b+sr+Latn/strings.xml
+++ b/quickstep/res/values-b+sr+Latn/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Preklopna traka zadataka"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Premesti gore levo"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Premesti dole desno"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Otvori aplikaciju kao oblačić"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{dodatna aplikacija}one{dodatna aplikacija}few{dodatne aplikacije}other{dodatnih aplikacija}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Računar"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> i <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Oblačić"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Preklopni"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> – <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Ikona aplikacije"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Naziv aplikacije"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Dugme Zatvori"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Zakači za traku zad."</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Otkači sa trake zad."</string>
 </resources>
diff --git a/quickstep/res/values-be/strings.xml b/quickstep/res/values-be/strings.xml
index 436ed3f..20c914d 100644
--- a/quickstep/res/values-be/strings.xml
+++ b/quickstep/res/values-be/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Меню з пашырэннем панэлі задач"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Перамясціць уверх/улева"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Перамясціць уніз/управа"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Адкрыць праграму ва ўсплывальным акне"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{даступная праграма}one{даступная праграма}few{даступныя праграмы}many{даступных праграм}other{даступнай праграмы}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Працоўны стол"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> і <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Бурбалкі"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Меню з пашырэннем"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g>, крыніца: <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Значок праграмы"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Назва праграмы"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Кнопка \"Закрыць\""</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Замацаваць на панэлі"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Адмацаваць ад панэлі"</string>
 </resources>
diff --git a/quickstep/res/values-bg/strings.xml b/quickstep/res/values-bg/strings.xml
index 922a473..414219a 100644
--- a/quickstep/res/values-bg/strings.xml
+++ b/quickstep/res/values-bg/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Меню при препълване на лентата на задачите"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Преместване горе/вляво"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Преместване долу/вдясно"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Отваряне на приложението като балонче"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{допълнително приложение}other{допълнителни приложения}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Режим за настолни компютри"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> и <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Балонче"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Препълване"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> от <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Икона на приложението"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Име на приложението"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Бутон за затваряне"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Лент. на зад.: фикс."</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Лент. на зад.: осв."</string>
 </resources>
diff --git a/quickstep/res/values-bn/strings.xml b/quickstep/res/values-bn/strings.xml
index 974994a..001c008 100644
--- a/quickstep/res/values-bn/strings.xml
+++ b/quickstep/res/values-bn/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"টাস্কবার ওভারফ্লো"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"উপরে/বাঁদিকে সরান"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"নিচে/ডানদিকে সরান"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"বাবল হিসেবে অ্যাপ খুলুন"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{আরও অ্যাপ}one{আরও অ্যাপ}other{আরও অ্যাপ}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"ডেস্কটপ"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> ও <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"বাবল"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"ওভারফ্লো"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="APP_NAME">%2$s</xliff:g> থেকে <xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"অ্যাপ আইকন"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"অ্যাপের শিরোনাম"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"বন্ধ করার বোতাম"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"টাস্কবারে পিন করুন"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"টাস্কবার থেকে আনপিন করুন"</string>
 </resources>
diff --git a/quickstep/res/values-bs/strings.xml b/quickstep/res/values-bs/strings.xml
index c89f84a..1eb88aa 100644
--- a/quickstep/res/values-bs/strings.xml
+++ b/quickstep/res/values-bs/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Preklopni meni trake zadataka"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Premjesti gore lijevo"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Premjesti dolje desno"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Otvori aplikaciju kao oblačić"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{dodatna aplikacija}one{dodatna aplikacija}few{dodatne aplikacije}other{dodatnih aplikacija}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Računar"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> i <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Oblačić"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Preklopni meni"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> iz aplikacije <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Ikona aplikacije"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Naslov aplikacije"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Dugme za zatvaranje"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Zakači na traku zadataka"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Otkači s trake zadataka"</string>
 </resources>
diff --git a/quickstep/res/values-ca/strings.xml b/quickstep/res/values-ca/strings.xml
index 87591da..6397b14 100644
--- a/quickstep/res/values-ca/strings.xml
+++ b/quickstep/res/values-ca/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Menú addicional de la barra de tasques"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Mou a la part superior o a l\'esquerra"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Mou a la part inferior o a la dreta"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Obre l\'aplicació com a bombolla"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{aplicació més}other{aplicacions més}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Escriptori"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> i <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Bombolla"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Desbordament"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> de <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Icona de l\'aplicació"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Títol de l\'aplicació"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Botó Tanca"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Fixa a barra tasques"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Deixa de fixar"</string>
 </resources>
diff --git a/quickstep/res/values-cs/strings.xml b/quickstep/res/values-cs/strings.xml
index 6d53ca8..3b000ef 100644
--- a/quickstep/res/values-cs/strings.xml
+++ b/quickstep/res/values-cs/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Přetečení panelu aplikací"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Přesunout doleva nahoru"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Přesunout doprava dolů"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Otevřít aplikaci jako bublinu"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{další aplikace}few{další aplikace}many{další aplikace}other{dalších aplikací}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Počítač"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> a <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Bublina"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Rozbalovací nabídka"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> z aplikace <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Ikona aplikace"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Název aplikace"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Tlačítko Zavřít"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Připnout na panel"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Odepnout z panelu"</string>
 </resources>
diff --git a/quickstep/res/values-da/strings.xml b/quickstep/res/values-da/strings.xml
index debea45..cf45967 100644
--- a/quickstep/res/values-da/strings.xml
+++ b/quickstep/res/values-da/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Prikmenu på proceslinjen"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Flyt til toppen eller venstre side"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Flyt til bunden eller højre side"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Åbn appen som en boble"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{yderligere app}one{yderligere app}other{yderligere apps}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Computertilstand"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> og <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Boble"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Overløb"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> fra <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Appikon"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Apptitel"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Knappen Luk"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Fastgør til proceslinje"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Frigør fra proceslinje"</string>
 </resources>
diff --git a/quickstep/res/values-de/strings.xml b/quickstep/res/values-de/strings.xml
index b4d5ac1..f15838e 100644
--- a/quickstep/res/values-de/strings.xml
+++ b/quickstep/res/values-de/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Dreipunkt-Menü der Taskleiste"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Nach oben / Nach links verschieben"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Nach unten / Nach rechts verschieben"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"App als Bubble öffnen"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{weitere App}other{weitere Apps}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Desktopmodus"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> und <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Bubble"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Weitere Optionen"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"„<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g>“ aus <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"App-Symbol"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Titel der App"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Schaltfläche „Schließen“"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"An Taskleiste pinnen"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Von Taskleiste lösen"</string>
 </resources>
diff --git a/quickstep/res/values-el/strings.xml b/quickstep/res/values-el/strings.xml
index 5dde857..a94a2f2 100644
--- a/quickstep/res/values-el/strings.xml
+++ b/quickstep/res/values-el/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Υπερχείλιση γραμμής εργαλείων"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Μετακίνηση επάνω/αριστερά"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Μετακίνηση κάτω/δεξιά"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Άνοιγμα εφαρμογής σε συννεφάκι"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{ακόμη εφαρμογή}other{ακόμη εφαρμογές}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Υπολογιστής"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> και <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Συννεφάκι"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Υπερχείλιση"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> από <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Εικονίδιο εφαρμογής"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Τίτλος εφαρμογής"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Κουμπί κλεισίματος"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Καρφ. σε γρ. εργαλ."</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Ξεκαρφ. από γρ. εργαλ."</string>
 </resources>
diff --git a/quickstep/res/values-en-rAU/strings.xml b/quickstep/res/values-en-rAU/strings.xml
index eef812c..9082df4 100644
--- a/quickstep/res/values-en-rAU/strings.xml
+++ b/quickstep/res/values-en-rAU/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Taskbar overflow"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Move to top/left"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Move to bottom/right"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Open app as a bubble"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{more app}other{more apps}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Desktop"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> and <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Bubble"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Overflow"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> from <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"App icon"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"App title"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Close button"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Pin to taskbar"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Unpin from taskbar"</string>
 </resources>
diff --git a/quickstep/res/values-en-rCA/strings.xml b/quickstep/res/values-en-rCA/strings.xml
index d1319ce..0d9e572 100644
--- a/quickstep/res/values-en-rCA/strings.xml
+++ b/quickstep/res/values-en-rCA/strings.xml
@@ -140,9 +140,16 @@
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Move to top/left"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Move to bottom/right"</string>
     <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Open app as a bubble"</string>
+    <string name="quick_switch_pane_title" msgid="4677158207760585812">"Recent apps"</string>
+    <string name="quick_switch_content_description" msgid="2851244536728720005">"Recent app list"</string>
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{more app}other{more apps}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Desktop"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> and <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <string name="quick_switch_task_with_position_in_parent" msgid="4968670948331508951">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, item <xliff:g id="INDEX_IN_PARENT">%2$d</xliff:g> of <xliff:g id="TOTAL_TASKS">%3$d</xliff:g>"</string>
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Bubble"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Overflow"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> from <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
diff --git a/quickstep/res/values-en-rGB/strings.xml b/quickstep/res/values-en-rGB/strings.xml
index eef812c..9082df4 100644
--- a/quickstep/res/values-en-rGB/strings.xml
+++ b/quickstep/res/values-en-rGB/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Taskbar overflow"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Move to top/left"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Move to bottom/right"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Open app as a bubble"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{more app}other{more apps}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Desktop"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> and <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Bubble"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Overflow"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> from <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"App icon"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"App title"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Close button"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Pin to taskbar"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Unpin from taskbar"</string>
 </resources>
diff --git a/quickstep/res/values-en-rIN/strings.xml b/quickstep/res/values-en-rIN/strings.xml
index eef812c..9082df4 100644
--- a/quickstep/res/values-en-rIN/strings.xml
+++ b/quickstep/res/values-en-rIN/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Taskbar overflow"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Move to top/left"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Move to bottom/right"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Open app as a bubble"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{more app}other{more apps}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Desktop"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> and <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Bubble"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Overflow"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> from <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"App icon"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"App title"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Close button"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Pin to taskbar"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Unpin from taskbar"</string>
 </resources>
diff --git a/quickstep/res/values-es-rUS/strings.xml b/quickstep/res/values-es-rUS/strings.xml
index 17e3a7d..78bb88a 100644
--- a/quickstep/res/values-es-rUS/strings.xml
+++ b/quickstep/res/values-es-rUS/strings.xml
@@ -140,9 +140,19 @@
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Mover a la parte superior o izquierda"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Mover a la parte inferior o derecha"</string>
     <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Abrir app como burbuja"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
+    <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{app más}other{apps más}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Escritorio"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> y <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Burbuja"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Ampliada"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> de <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
diff --git a/quickstep/res/values-es/strings.xml b/quickstep/res/values-es/strings.xml
index 69628cf..542e8aa 100644
--- a/quickstep/res/values-es/strings.xml
+++ b/quickstep/res/values-es/strings.xml
@@ -92,7 +92,7 @@
     <string name="allset_button_hint" msgid="2395219947744706291">"Toca el botón de inicio para ir a la pantalla de inicio"</string>
     <string name="allset_description_generic" msgid="5385500062202019855">"Ya puedes empezar a usar tu <xliff:g id="DEVICE">%1$s</xliff:g>"</string>
     <string name="default_device_name" msgid="6660656727127422487">"dispositivo"</string>
-    <string name="allset_navigation_settings" msgid="4713404605961476027"><annotation id="link">"Ajustes de navegación del sistema"</annotation></string>
+    <string name="allset_navigation_settings" msgid="4713404605961476027"><annotation id="link">"Opciones de navegación"</annotation></string>
     <string name="action_share" msgid="2648470652637092375">"Compartir"</string>
     <string name="action_screenshot" msgid="8171125848358142917">"Hacer captura"</string>
     <string name="action_split" msgid="2098009717623550676">"Dividir"</string>
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Barra de tareas ampliada"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Mover arriba/a la izquierda"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Mover abajo/a la derecha"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Abrir aplicación como burbuja"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{app más}other{apps más}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Ordenador"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> y <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Burbuja"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Menú adicional"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> de <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Icono de la aplicación"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Título de la aplicación"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Botón de cerrar"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Fijar a la barra"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Desfijar de la barra"</string>
 </resources>
diff --git a/quickstep/res/values-et/strings.xml b/quickstep/res/values-et/strings.xml
index 41cb357..66d0b9f 100644
--- a/quickstep/res/values-et/strings.xml
+++ b/quickstep/res/values-et/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Tegumiriba ületäide"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Teisalda üles/vasakule"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Teisalda alla/paremale"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Rakenduse avamine mullina"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{rakendus veel}other{rakendust veel}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Lauaarvuti"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> ja <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Mull"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Ületäide"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> – <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Rakenduse ikoon"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Rakenduse pealkiri"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Sulgemisnupp"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Tegumiribale kinnitamine"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Tegumiribalt vabastamine"</string>
 </resources>
diff --git a/quickstep/res/values-eu/strings.xml b/quickstep/res/values-eu/strings.xml
index 15c4742..618992c 100644
--- a/quickstep/res/values-eu/strings.xml
+++ b/quickstep/res/values-eu/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Zereginen barraren luzapena"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Eraman gora, ezkerretara"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Eraman behera, eskuinetara"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Ireki aplikazioa burbuila gisa"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{aplikazio gehiago}other{aplikazio gehiago}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Ordenagailua"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> eta <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Burbuila"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Luzapena"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> (<xliff:g id="APP_NAME">%2$s</xliff:g>)"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Aplikazioaren ikonoa"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Aplikazioaren izena"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Ixteko botoia"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Ainguratu zereginen barran"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Kendu aingura zereginen barratik"</string>
 </resources>
diff --git a/quickstep/res/values-fa/strings.xml b/quickstep/res/values-fa/strings.xml
index 810632b..9745b58 100644
--- a/quickstep/res/values-fa/strings.xml
+++ b/quickstep/res/values-fa/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"سرریز نوار وظیفه"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"انتقال به بالا/ چپ"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"انتقال به پایین/ راست"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"باز کردن برنامه به‌صورت حبابک"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{برنامه دیگر}one{برنامه دیگر}other{برنامه دیگر}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"رایانه"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> و <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"حبابک"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"سرریز"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> از <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"نماد برنامه"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"عنوان برنامه"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"دکمه بستن"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"سنجاق به نوار وظیفه"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"برداشتن از نواروظیفه"</string>
 </resources>
diff --git a/quickstep/res/values-fi/strings.xml b/quickstep/res/values-fi/strings.xml
index e23ae30..af132e7 100644
--- a/quickstep/res/values-fi/strings.xml
+++ b/quickstep/res/values-fi/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Tehtäväpalkin ylivuotu"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Siirrä ylös tai vasemmalle"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Siirrä alas tai oikealle"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Avaa sovellus kuplana"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{muu sovellus}other{muuta sovellusta}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Tietokone"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> ja <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Kupla"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Ylivuoto"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g>: <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Sovelluskuvake"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Sovelluksen nimi"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Sulje-painike"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Kiinnitä palkkiin"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Poista palkista"</string>
 </resources>
diff --git a/quickstep/res/values-fr-rCA/strings.xml b/quickstep/res/values-fr-rCA/strings.xml
index 448abf5..6c4fcc4 100644
--- a/quickstep/res/values-fr-rCA/strings.xml
+++ b/quickstep/res/values-fr-rCA/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Barre des tâches à développer"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Déplacer vers le coin supérieur gauche de l\'écran"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Déplacer vers le coin inférieur droit de l\'écran"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Ouvrir l\'appli sous forme de bulle"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{autre appli}one{autre appli}other{autres applis}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Bureau"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> et <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Bulle"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Bulle à développer"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> de <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Icône de l\'appli"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Nom de l\'appli"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Bouton Fermer"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Éping. (barre tâche)"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Détacher (bar. tâc.)"</string>
 </resources>
diff --git a/quickstep/res/values-fr/strings.xml b/quickstep/res/values-fr/strings.xml
index 59310e2..09079d8 100644
--- a/quickstep/res/values-fr/strings.xml
+++ b/quickstep/res/values-fr/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Développement de la barre des tâches"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Déplacer en haut ou à gauche"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Déplacer en bas ou à droite"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Ouvrir l\'appli sous forme de bulle"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{autre application}one{autre application}other{autres applications}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Mode ordinateur"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> et <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Bulle"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Dépassement"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> (<xliff:g id="APP_NAME">%2$s</xliff:g>)"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Icône de l\'application"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Titre de l\'application"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Bouton \"Fermer\""</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Épingler à la barre"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Désépingler de la barre"</string>
 </resources>
diff --git a/quickstep/res/values-gl/strings.xml b/quickstep/res/values-gl/strings.xml
index 994b5fd..3840b5e 100644
--- a/quickstep/res/values-gl/strings.xml
+++ b/quickstep/res/values-gl/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Menú adicional da barra de tarefas"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Mover á parte superior ou á esquerda"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Mover á parte inferior ou á dereita"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Abrir aplicación como unha burbulla"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{aplicación máis}other{aplicacións máis}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Escritorio"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> e <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Burbulla"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Menú adicional"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> de <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Icona da aplicación"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Título da aplicación"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Botón Pechar"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Fixar na barra"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Soltar da barra"</string>
 </resources>
diff --git a/quickstep/res/values-gu/strings.xml b/quickstep/res/values-gu/strings.xml
index 03fbd63..c39fe20 100644
--- a/quickstep/res/values-gu/strings.xml
+++ b/quickstep/res/values-gu/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"ટાસ્કબાર ઓવરફ્લો"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"સૌથી ઉપર ડાબી બાજુએ ખસેડો"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"સૌથી નીચે જમણી બાજુએ ખસેડો"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"બબલ તરીકે ઍપ ખોલો"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{વધુ ઍપ}one{વધુ ઍપ}other{વધુ ઍપ}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"ડેસ્કટૉપ"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> અને <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"બબલ"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"ઓવરફ્લો"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="APP_NAME">%2$s</xliff:g>થી <xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"ઍપનું આઇકન"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"ઍપનું શીર્ષક"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"\'બંધ કરો\' બટન"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"ટાસ્કબારમાં પિન કરો"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"ટાસ્કબારમાંથી અનપિન કરો"</string>
 </resources>
diff --git a/quickstep/res/values-hi/strings.xml b/quickstep/res/values-hi/strings.xml
index 89648d4..af24811 100644
--- a/quickstep/res/values-hi/strings.xml
+++ b/quickstep/res/values-hi/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"टास्कबार ओवरफ़्लो आइकॉन"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"ऊपर/बाईं तरफ़ ले जाएं"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"नीचे/दाईं तरफ़ ले जाएं"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"ऐप्लिकेशन को बबल के तौर पर खोलें"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{ज़्यादा ऐप्लिकेशन}one{ज़्यादा ऐप्लिकेशन}other{ज़्यादा ऐप्लिकेशन}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"डेस्कटॉप"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> और <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"बबल"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"ओवरफ़्लो"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="APP_NAME">%2$s</xliff:g> की <xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> वाली सूचना"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"ऐप्लिकेशन आइकॉन"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"ऐप्लिकेशन का नाम"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"\'बंद करें\' बटन"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"टास्कबार में पिन करें"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"टास्कबार से अनपिन करें"</string>
 </resources>
diff --git a/quickstep/res/values-hr/strings.xml b/quickstep/res/values-hr/strings.xml
index e4a0f7c..fca73aa 100644
--- a/quickstep/res/values-hr/strings.xml
+++ b/quickstep/res/values-hr/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Dodatni izbornik trake sa zadacima"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Premjesti gore/lijevo"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Premjesti dolje/desno"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Otvori aplikaciju kao oblačić"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{dodatna aplikacija}one{dodatna aplikacija}few{dodatne aplikacije}other{dodatnih aplikacija}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Računalo"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> i <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Oblačić"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Dodatni izbornik"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g>, <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Ikona aplikacije"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Naziv aplikacije"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Gumb Zatvori"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Prikvači na traku"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Otkvači s trake"</string>
 </resources>
diff --git a/quickstep/res/values-hu/strings.xml b/quickstep/res/values-hu/strings.xml
index ac97372..6584eaf 100644
--- a/quickstep/res/values-hu/strings.xml
+++ b/quickstep/res/values-hu/strings.xml
@@ -139,11 +139,17 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Feladatsáv túlcsordulása"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Mozgatás felülre vagy a bal oldalra"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Mozgatás alulra vagy a jobb oldalra"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
-    <skip />
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Alkalmazás megnyitása buborékként"</string>
+    <string name="quick_switch_pane_title" msgid="4677158207760585812">"Legutóbbi alkalmazások"</string>
+    <string name="quick_switch_content_description" msgid="2851244536728720005">"Legutóbbi alkalmazások listája"</string>
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{további alkalmazás}other{további alkalmazás}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Asztali"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> és <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <string name="quick_switch_task_with_position_in_parent" msgid="4968670948331508951">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="INDEX_IN_PARENT">%2$d</xliff:g>. elem, összesen ennyiből: <xliff:g id="TOTAL_TASKS">%3$d</xliff:g>"</string>
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Buborék"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Túlcsordulás"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g>, forrás: <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +163,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Alkalmazásikon"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Alkalmazás neve"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Bezárás gomb"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Kitűzés a feladatsávon"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Kitűzés feloldása"</string>
 </resources>
diff --git a/quickstep/res/values-hy/strings.xml b/quickstep/res/values-hy/strings.xml
index 27ac837..184e281 100644
--- a/quickstep/res/values-hy/strings.xml
+++ b/quickstep/res/values-hy/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Հավելվածների վահանակի լրացուցիչ ընտրացանկ"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Տեղափոխել վերևի ձախ անկյուն"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Տեղափոխել ներքևի աջ անկյուն"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Բացել հավելվածը պղպջակի ձևով"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{լրացուցիչ հավելված}one{լրացուցիչ հավելված}other{լրացուցիչ հավելված}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Համակարգիչ"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> և <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Ամպիկ"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Լրացուցիչ ընտրացանկ"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g>՝ <xliff:g id="APP_NAME">%2$s</xliff:g> հավելվածից"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Հավելվածի պատկերակ"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Հավելվածի անվանում"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"«Փակել» կոճակ"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Ամրացնել վահանակում"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Ապամրացնել վահանակից"</string>
 </resources>
diff --git a/quickstep/res/values-in/strings.xml b/quickstep/res/values-in/strings.xml
index 69a2a82..19ce0ad 100644
--- a/quickstep/res/values-in/strings.xml
+++ b/quickstep/res/values-in/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Tambahan Taskbar"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Pindahkan ke atas/kiri"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Pindahkan ke bawah/kanan"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Buka aplikasi sebagai balon"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{aplikasi lainnya}other{aplikasi lainnya}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Desktop"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> dan <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Balon"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Tambahan"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> dari <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Ikon aplikasi"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Judul aplikasi"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Tombol tutup"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Sematkan ke taskbar"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Lepaskan dari taskbar"</string>
 </resources>
diff --git a/quickstep/res/values-is/strings.xml b/quickstep/res/values-is/strings.xml
index a8c2770..77e2fd0 100644
--- a/quickstep/res/values-is/strings.xml
+++ b/quickstep/res/values-is/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Yfirflæði á forritastiku"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Færa efst/til vinstri"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Færa neðst/til hægri"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Opna forrit sem blöðru"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{forrit til viðbótar}one{forrit til viðbótar}other{forrit til viðbótar}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Skjáborð"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> og <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Blaðra"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Yfirflæði"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> frá <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Forritstákn"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Titil forrits"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Hnappur til að loka"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Festa á forritastiku"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Losa af forritastiku"</string>
 </resources>
diff --git a/quickstep/res/values-it/strings.xml b/quickstep/res/values-it/strings.xml
index 7d0bcd8..2069ece 100644
--- a/quickstep/res/values-it/strings.xml
+++ b/quickstep/res/values-it/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Overflow barra delle app"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Sposta in alto/a sinistra"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Sposta in basso/a destra"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Apri l\'app come fumetto"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{altra app}other{altre app}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Desktop"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> e <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Fumetto"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Extra"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> da <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Icona dell\'app"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Titolo dell\'app"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Pulsante Chiudi"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Fissa alla barra app"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Sblocca da barra app"</string>
 </resources>
diff --git a/quickstep/res/values-iw/strings.xml b/quickstep/res/values-iw/strings.xml
index 55295cf..2b2302b 100644
--- a/quickstep/res/values-iw/strings.xml
+++ b/quickstep/res/values-iw/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"אפשרויות נוספות בסרגל האפליקציות"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"העברה לפינה השמאלית/העליונה"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"העברה לפינה הימנית/התחתונה"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"פתיחת האפליקציה בבועה"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{אפליקציה נוספת}one{אפליקציות נוספות}two{אפליקציות נוספות}other{אפליקציות נוספות}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"מחשב"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> ו-<xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"בועה"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"אפשרויות נוספות"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"‫<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> מתוך <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"סמל האפליקציה"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"שם האפליקציה"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"כפתור הסגירה"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"הצמדה לסרגל האפליקציות"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"ביטול ההצמדה לסרגל"</string>
 </resources>
diff --git a/quickstep/res/values-ja/strings.xml b/quickstep/res/values-ja/strings.xml
index b66126f..596e104 100644
--- a/quickstep/res/values-ja/strings.xml
+++ b/quickstep/res/values-ja/strings.xml
@@ -140,9 +140,16 @@
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"上 / 左に移動"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"下 / 右に移動"</string>
     <string name="open_app_as_a_bubble" msgid="6642626287247807473">"アプリをバブルとして開く"</string>
+    <string name="quick_switch_pane_title" msgid="4677158207760585812">"最近使ったアプリ"</string>
+    <string name="quick_switch_content_description" msgid="2851244536728720005">"最近使ったアプリの一覧"</string>
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{個のその他のアプリ}other{個のその他のアプリ}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"デスクトップ"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> と <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <string name="quick_switch_task_with_position_in_parent" msgid="4968670948331508951">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>、アイテム <xliff:g id="INDEX_IN_PARENT">%2$d</xliff:g>/<xliff:g id="TOTAL_TASKS">%3$d</xliff:g>"</string>
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"ふきだし"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"オーバーフロー"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g>（<xliff:g id="APP_NAME">%2$s</xliff:g>）"</string>
diff --git a/quickstep/res/values-ka/strings.xml b/quickstep/res/values-ka/strings.xml
index 0608631..c590ade 100644
--- a/quickstep/res/values-ka/strings.xml
+++ b/quickstep/res/values-ka/strings.xml
@@ -140,9 +140,19 @@
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"ზემოთ/მარცხნივ გადატანა"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"ქვემოთ/მარჯვნივ გადატანა"</string>
     <string name="open_app_as_a_bubble" msgid="6642626287247807473">"აპის გახსნა ბუშტის სახით"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
+    <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{სხვა აპი}other{სხვა აპი}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"დესკტოპი"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> და <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"ბუშტი"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"გადავსება"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g>: <xliff:g id="APP_NAME">%2$s</xliff:g>-იდან"</string>
diff --git a/quickstep/res/values-kk/strings.xml b/quickstep/res/values-kk/strings.xml
index 8e18fab..b9785a4 100644
--- a/quickstep/res/values-kk/strings.xml
+++ b/quickstep/res/values-kk/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"\"Тапсырмалар жолағы\" қосымша мәзірі"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Жоғары/солға жылжыту"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Төмен/оңға жылжыту"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Қолданбаны қалқыма терезе түрінде ашу"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{қосымша қолданба}other{қосымша қолданба}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Компьютер"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> және <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Қалқыма терезе"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Қосымша мәзір"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="APP_NAME">%2$s</xliff:g> ұсынатын <xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Қолданба белгішесі"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Қолданба атауы"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"\"Жабу\" түймесі"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Тапсырмалар жолағына бекіту"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Тапсырмалар жолағынан босату"</string>
 </resources>
diff --git a/quickstep/res/values-km/strings.xml b/quickstep/res/values-km/strings.xml
index 44f7fe4..a139ca3 100644
--- a/quickstep/res/values-km/strings.xml
+++ b/quickstep/res/values-km/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"ម៉ឺនុយបន្ថែមរបារកិច្ចការ"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"ផ្លាស់ទីទៅខាងលើ/ឆ្វេង"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"ផ្លាស់ទីទៅខាងក្រោម/ស្ដាំ"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"បើកកម្មវិធីជាផ្ទាំងសារ"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{កម្មវិធីច្រើនទៀត}other{កម្មវិធីច្រើនទៀត}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"អេក្រង់ដើម"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> និង <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"ផ្ទាំងសារ"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"ម៉ឺនុយបន្ថែម"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> ពី <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"រូបកម្មវិធី"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"ចំណងជើងកម្មវិធី"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"ប៊ូតុងបិទ"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"ខ្ទាស់ទៅរបារកិច្ចការ"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"ដកខ្ទាស់ពីរបារកិច្ចការ"</string>
 </resources>
diff --git a/quickstep/res/values-kn/strings.xml b/quickstep/res/values-kn/strings.xml
index 2187634..a1907d5 100644
--- a/quickstep/res/values-kn/strings.xml
+++ b/quickstep/res/values-kn/strings.xml
@@ -140,9 +140,19 @@
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"ಮೇಲಿನ/ಎಡಭಾಗಕ್ಕೆ ಸರಿಸಿ"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"ಕೆಳಗಿನ/ಬಲಭಾಗಕ್ಕೆ ಸರಿಸಿ"</string>
     <string name="open_app_as_a_bubble" msgid="6642626287247807473">"ಆ್ಯಪ್ ಅನ್ನು ಬಬಲ್ ಆಗಿ ತೆರೆಯಿರಿ"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
+    <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{ಹೆಚ್ಚಿನ ಆ್ಯಪ್‌}one{ಹೆಚ್ಚಿನ ಆ್ಯಪ್‌ಗಳು}other{ಹೆಚ್ಚಿನ ಆ್ಯಪ್‌ಗಳು}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"ಡೆಸ್ಕ್‌ಟಾಪ್"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> ಮತ್ತು <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"ಬಬಲ್"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"ಓವರ್‌ಫ್ಲೋ"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="APP_NAME">%2$s</xliff:g> ನಿಂದ <xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g>"</string>
diff --git a/quickstep/res/values-ko/strings.xml b/quickstep/res/values-ko/strings.xml
index e5e5359..1e7e850 100644
--- a/quickstep/res/values-ko/strings.xml
+++ b/quickstep/res/values-ko/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"태스크 바 오버플로"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"상단/왼쪽으로 이동"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"하단/오른쪽으로 이동"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"앱을 대화창으로 열기"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{추가 앱}other{추가 앱}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"데스크톱"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> 및 <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"풍선"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"더보기"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="APP_NAME">%2$s</xliff:g>의 <xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"앱 아이콘"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"앱 제목"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"닫기 버튼"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"태스크 바에 고정"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"태스크 바에서 고정 해제"</string>
 </resources>
diff --git a/quickstep/res/values-ky/strings.xml b/quickstep/res/values-ky/strings.xml
index d23ee7e..3190dee 100644
--- a/quickstep/res/values-ky/strings.xml
+++ b/quickstep/res/values-ky/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"\"Тапшырмалар панели\" кошумча менюсу"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Жогорку/сол бурчка жылдыруу"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Төмөнкү/оң бурчка жылдыруу"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Колдонмону көбүкчө катары ачуу"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{колдонмо бар}other{колдонмо бар}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Компьютер"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> жана <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Көбүкчө"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Кошумча меню"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="APP_NAME">%2$s</xliff:g> колдонмосунан <xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Колдонмонун сүрөтчөсү"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Колдонмонун аталышы"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Жабуу баскычы"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Тапшырмалар панелине кадоо"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Тапшырмалар панелинен алып коюу"</string>
 </resources>
diff --git a/quickstep/res/values-lo/strings.xml b/quickstep/res/values-lo/strings.xml
index 8407311..42b487e 100644
--- a/quickstep/res/values-lo/strings.xml
+++ b/quickstep/res/values-lo/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"ສ່ວນເພີ່ມເຕີມຂອງແຖບໜ້າວຽກ"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"ຍ້າຍໄປຊ້າຍ/ເທິງ"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"ຍ້າຍໄປຂວາ/ລຸ່ມ"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"ເປີດແອັບເປັນຟອງ"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{ແອັບເພີ່ມເຕີມ}other{ແອັບເພີ່ມເຕີມ}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"ເດັສທັອບ"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> ແລະ <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"ຟອງ"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"ລາຍການເພີ່ມເຕີມ"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> ຈາກ <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"ໄອຄອນແອັບ"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"ຊື່ແອັບ"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"ປຸ່ມປິດ"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"ປັກໝຸດໄປໃສ່ແຖບໜ້າວຽກ"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"ຖອດປັກໝຸດຈາກແຖບໜ້າວຽກ"</string>
 </resources>
diff --git a/quickstep/res/values-lt/strings.xml b/quickstep/res/values-lt/strings.xml
index 268eeb7..20fcc80 100644
--- a/quickstep/res/values-lt/strings.xml
+++ b/quickstep/res/values-lt/strings.xml
@@ -140,9 +140,19 @@
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Perkelti aukštyn, kairėn"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Perkelti žemyn, dešinėn"</string>
     <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Atidaryti programą kaip burbulą"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
+    <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{papildoma programa}one{papildoma programa}few{papildomos programos}many{papildomos programos}other{papildomų programų}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Stalinis kompiuteris"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"„<xliff:g id="APP_NAME_1">%1$s</xliff:g>“ ir „<xliff:g id="APP_NAME_2">%2$s</xliff:g>“"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Burbulas"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Perpildymas"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"„<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g>“ iš „<xliff:g id="APP_NAME">%2$s</xliff:g>“"</string>
diff --git a/quickstep/res/values-lv/strings.xml b/quickstep/res/values-lv/strings.xml
index ad83c24..7b256a7 100644
--- a/quickstep/res/values-lv/strings.xml
+++ b/quickstep/res/values-lv/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Uzdevumu joslas pārpilde"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Pārvietot uz augšējo/kreiso stūri"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Pārvietot uz apakšējo/labo stūri"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Atvērt lietotni kā burbuli"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{papildu lietotne}zero{papildu lietotņu}one{papildu lietotne}other{papildu lietotnes}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Darbvirsma"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"“<xliff:g id="APP_NAME_1">%1$s</xliff:g>” un “<xliff:g id="APP_NAME_2">%2$s</xliff:g>”"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Burbulis"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Pārpilde"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> no lietotnes <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Lietotnes ikona"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Lietotnes nosaukums"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Poga Aizvērt"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Piespraust uzdevumu joslai"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Atspraust no uzdevumu joslas"</string>
 </resources>
diff --git a/quickstep/res/values-mk/strings.xml b/quickstep/res/values-mk/strings.xml
index 96edee6..08dc459 100644
--- a/quickstep/res/values-mk/strings.xml
+++ b/quickstep/res/values-mk/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Проширено балонче на „Лента со задачи“"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Премести горе лево"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Премести долу десно"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Отвори апликација како балонче"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{дополнителна апликација}one{дополнителна апликација}other{дополнителни апликации}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Режим за компјутер"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> и <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Балонче"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Проширено балонче"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> од <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Икона за апликацијата"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Наслов на апликацијата"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Копче за затворање"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Закачи на лентата"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Откачи од лентата"</string>
 </resources>
diff --git a/quickstep/res/values-ml/strings.xml b/quickstep/res/values-ml/strings.xml
index 628acd1..9b87841 100644
--- a/quickstep/res/values-ml/strings.xml
+++ b/quickstep/res/values-ml/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"ടാസ്‌ക്ബാർ ഓവർഫ്ലോ"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"മുകളിലേക്കോ ഇടത്തേക്കോ നീക്കുക"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"താഴേക്കോ വലത്തേക്കോ നീക്കുക"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"ആപ്പ് ഒരു ബബിളായി തുറക്കുക"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{കൂടുതൽ ആപ്പ്}other{കൂടുതൽ ആപ്പുകൾ}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"ഡെസ്‌ക്ടോപ്പ്"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g>, <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"ബബിൾ"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"ഓവർഫ്ലോ"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="APP_NAME">%2$s</xliff:g> എന്നതിൽ നിന്നുള്ള <xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"ആപ്പ് ഐക്കൺ"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"ആപ്പിന്റെ പേര്"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"അടയ്ക്കുക ബട്ടൺ"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"ടാസ്ക്ബാറിൽ ചേർക്കൂ"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"ടാസ്ക്ബാറിൽ നിന്ന് മാറ്റൂ"</string>
 </resources>
diff --git a/quickstep/res/values-mn/strings.xml b/quickstep/res/values-mn/strings.xml
index ac3c40e..f390e21 100644
--- a/quickstep/res/values-mn/strings.xml
+++ b/quickstep/res/values-mn/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Ажлын хэсгийн урт цэс"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Зүүн дээд хэсэг рүү зөөх"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Баруун доод хэсэг рүү зөөх"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Аппыг бөмбөлөг байдлаар нээх"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{бусад апп}other{бусад апп}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Дэлгэц"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> болон <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Бөмбөлөг"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Илүү хэсэг"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="APP_NAME">%2$s</xliff:g>-с ирсэн <xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Aппын дүрс тэмдэг"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Аппын нэр"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Хаах товч"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Ажлын хэсэгт бэхлэх"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Бэхэлснийг болиулах"</string>
 </resources>
diff --git a/quickstep/res/values-mr/strings.xml b/quickstep/res/values-mr/strings.xml
index 6f82343..4e6d309 100644
--- a/quickstep/res/values-mr/strings.xml
+++ b/quickstep/res/values-mr/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"टास्कबार ओव्हरफ्लो"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"सर्वात वरती/डावीकडे हलवा"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"तळाशी/उजवीकडे हलवा"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"बबल म्हणून अ‍ॅप उघडा"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{आणखी अ‍ॅप}other{आणखी अ‍ॅप्स}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"डेस्कटॉप"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> आणि <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"बबल"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"ओव्हरफ्लो"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="APP_NAME">%2$s</xliff:g> वरील <xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"अ‍ॅपचा आयकन"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"अ‍ॅपचे शीर्षक"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"बंद करा बटण"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"टास्कबारवर पिन करा"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"टास्कबारवरून अनपिन करा"</string>
 </resources>
diff --git a/quickstep/res/values-ms/strings.xml b/quickstep/res/values-ms/strings.xml
index b85b62c..a633bf4 100644
--- a/quickstep/res/values-ms/strings.xml
+++ b/quickstep/res/values-ms/strings.xml
@@ -139,11 +139,17 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Limpahan Bar Tugas"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Alihkan ke atas/kiri"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Alihkan ke bawah/kanan"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
-    <skip />
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Buka apl sebagai gelembung"</string>
+    <string name="quick_switch_pane_title" msgid="4677158207760585812">"Apl terbaharu"</string>
+    <string name="quick_switch_content_description" msgid="2851244536728720005">"Senarai apl terbaharu"</string>
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{apl lagi}other{apl lagi}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Desktop"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> dan <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <string name="quick_switch_task_with_position_in_parent" msgid="4968670948331508951">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="INDEX_IN_PARENT">%2$d</xliff:g> item daripada <xliff:g id="TOTAL_TASKS">%3$d</xliff:g>"</string>
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Gelembung"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Limpahan"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> daripada <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +163,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Ikon apl"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Tajuk apl"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Butang tutup"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Semat pada bar tugas"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Nyahsemat drpd bar tugas"</string>
 </resources>
diff --git a/quickstep/res/values-my/strings.xml b/quickstep/res/values-my/strings.xml
index 467ef26..8f90b8b 100644
--- a/quickstep/res/values-my/strings.xml
+++ b/quickstep/res/values-my/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Taskbar မီနူးအပို"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"အပေါ်/ဘယ်ဘက်သို့ ရွှေ့ရန်"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"အောက်ခြေ/ညာဘက်သို့ ရွှေ့ရန်"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"အက်ပ်ကို ပူဖောင်းကွက်အဖြစ် ဖွင့်ရန်"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{နောက်ထပ်အက်ပ်}other{နောက်ထပ်အက်ပ်များ}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"ဒက်စ်တော့"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> နှင့် <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"ပူဖောင်းကွက်"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"မီနူးအပို"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="APP_NAME">%2$s</xliff:g> မှ <xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"အက်ပ်သင်္ကေတ"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"အက်ပ်ခေါင်းစဉ်"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"အပိတ် ခလုတ်"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Taskbar ၌ ပင်ထိုးရန်"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Taskbar မှ ဖြုတ်ရန်"</string>
 </resources>
diff --git a/quickstep/res/values-nb/strings.xml b/quickstep/res/values-nb/strings.xml
index 2690a61..a5799c5 100644
--- a/quickstep/res/values-nb/strings.xml
+++ b/quickstep/res/values-nb/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Overflyt for oppgavelinjen"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Flytt til øverst/venstre"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Flytt til nederst/høyre"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Åpne appen som en boble"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{app til}other{apper til}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Skrivebord"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> og <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Boble"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Overflyt"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> fra <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Appikon"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Apptittel"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Lukkeknapp"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Fest i oppgavelinjen"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Løsne i oppgavelinje"</string>
 </resources>
diff --git a/quickstep/res/values-ne/strings.xml b/quickstep/res/values-ne/strings.xml
index d03fcce..b1b03e4 100644
--- a/quickstep/res/values-ne/strings.xml
+++ b/quickstep/res/values-ne/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"टास्कबार ओभरफ्लो"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"सिरान/बायाँतिर सार्नुहोस्"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"फेद/दायाँतिर सार्नुहोस्"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"एपलाई बबलका रूपमा खोल्नुहोस्"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{थप एप}other{थप एपहरू}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"डेस्कटप"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> र <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"बबल"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"ओभरफ्लो"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="APP_NAME">%2$s</xliff:g> मा देखाइएका <xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"एप जनाउने आइकन"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"एपको शीर्षक"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"\"बन्द गर्नुहोस्\" बटन"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"टास्कबारमा पिन गर्नुहोस्"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"टास्कबारबाट पिन गर्नुहोस्"</string>
 </resources>
diff --git a/quickstep/res/values-nl/strings.xml b/quickstep/res/values-nl/strings.xml
index d265f96..bd4dfc5 100644
--- a/quickstep/res/values-nl/strings.xml
+++ b/quickstep/res/values-nl/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Taakbalkoverloop"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Naar boven/links verplaatsen"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Naar beneden/rechts verplaatsen"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"App openen als ballon"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{extra app}other{extra apps}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Desktop"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> en <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Bubbel"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Overloop"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> van <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Icoon van app"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Titel van app"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Knop Sluiten"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Vastzetten op taakbalk"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Losmaken van taakbalk"</string>
 </resources>
diff --git a/quickstep/res/values-or/strings.xml b/quickstep/res/values-or/strings.xml
index e19fee5..7efa026 100644
--- a/quickstep/res/values-or/strings.xml
+++ b/quickstep/res/values-or/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"ଟାସ୍କବାର ଓଭରଫ୍ଲୋ"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"ଶୀର୍ଷ/ବାମକୁ ମୁଭ କରନ୍ତୁ"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"ନିମ୍ନ/ଡାହାଣକୁ ମୁଭ କରନ୍ତୁ"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"ଏକ ବବଲ ଭାବେ ଆପ ଖୋଲନ୍ତୁ"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{ଅଧିକ ଆପ}other{ଅଧିକ ଆପ୍ସ}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"ଡେସ୍କଟପ"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> ଏବଂ <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"ବବଲ"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"ଓଭରଫ୍ଲୋ"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="APP_NAME">%2$s</xliff:g>ରୁ <xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"ଆପ ଆଇକନ"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"ଆପ ଟାଇଟେଲ"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"\"ବନ୍ଦ କରନ୍ତୁ\" ବଟନ"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"ଟାସ୍କବାରରେ ପିନ କର"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"ଟାସ୍କବାରରୁ ଅନପିନ କର"</string>
 </resources>
diff --git a/quickstep/res/values-pa/strings.xml b/quickstep/res/values-pa/strings.xml
index 4a015e4..798619b 100644
--- a/quickstep/res/values-pa/strings.xml
+++ b/quickstep/res/values-pa/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"ਟਾਸਕਬਾਰ ਓਵਰਫ਼ਲੋ"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"ਸਿਖਰਲੇ/ਖੱਬੇ ਪਾਸੇ ਲੈ ਕੇ ਜਾਓ"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"ਹੇਠਾਂ/ਸੱਜੇ ਪਾਸੇ ਲੈ ਕੇ ਜਾਓ"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"ਐਪ ਨੂੰ ਬਬਲ ਵਜੋਂ ਖੋਲ੍ਹੋ"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{ਹੋਰ ਐਪ}one{ਹੋਰ ਐਪ}other{ਹੋਰ ਐਪਾਂ}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"ਡੈਸਕਟਾਪ"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> ਅਤੇ <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"ਬਬਲ"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"ਓਵਰਫ਼ਲੋ"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="APP_NAME">%2$s</xliff:g> ਤੋਂ <xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"ਐਪ ਪ੍ਰਤੀਕ"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"ਐਪ ਸਿਰਲੇਖ"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"\'ਬੰਦ ਕਰੋ\' ਬਟਨ"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"ਟਾਸਕਬਾਰ \'ਤੇ ਪਿੰਨ ਕਰੋ"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"ਟਾਸਕਬਾਰ ਤੋਂ ਅਣਪਿੰਨ ਕਰੋ"</string>
 </resources>
diff --git a/quickstep/res/values-pl/strings.xml b/quickstep/res/values-pl/strings.xml
index 89297a2..6f6b08b 100644
--- a/quickstep/res/values-pl/strings.xml
+++ b/quickstep/res/values-pl/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Rozwijany pasek aplikacji"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Przesuń w górny lewy róg"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Przesuń w dolny prawy róg"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Otwórz aplikację jako dymek"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{inna aplikacja}few{inne aplikacje}many{innych aplikacji}other{innej aplikacji}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Pulpit"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> i <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Dymek"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Rozwijany"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> z aplikacji <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Ikona aplikacji"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Tytuł aplikacji"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Przycisk Zamknij"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Przypnij do paska"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Odepnij od paska"</string>
 </resources>
diff --git a/quickstep/res/values-pt-rPT/strings.xml b/quickstep/res/values-pt-rPT/strings.xml
index 8c38182..7f3a3c2 100644
--- a/quickstep/res/values-pt-rPT/strings.xml
+++ b/quickstep/res/values-pt-rPT/strings.xml
@@ -140,9 +140,16 @@
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Mover para a parte superior esquerda"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Mover para a part superior direita"</string>
     <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Abrir app como um balão"</string>
+    <string name="quick_switch_pane_title" msgid="4677158207760585812">"Apps recentes"</string>
+    <string name="quick_switch_content_description" msgid="2851244536728720005">"Lista de apps recentes"</string>
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{outra app}other{outras apps}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Computador"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> e <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <string name="quick_switch_task_with_position_in_parent" msgid="4968670948331508951">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, item <xliff:g id="INDEX_IN_PARENT">%2$d</xliff:g> de <xliff:g id="TOTAL_TASKS">%3$d</xliff:g>"</string>
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Balão"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Menu adicional"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> da app <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
diff --git a/quickstep/res/values-pt/strings.xml b/quickstep/res/values-pt/strings.xml
index 5ea0194..892881b 100644
--- a/quickstep/res/values-pt/strings.xml
+++ b/quickstep/res/values-pt/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Barra de tarefas flutuante"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Mover para cima/para a esquerda"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Mover para baixo/para a direita"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Abrir o app como um balão"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{outro app}one{outro app}other{outros apps}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Computador"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> e <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Balão"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Balão flutuante"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> do app <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Ícone do app"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Título do app"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Botão \"Fechar\""</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Fixar na barra de tarefas"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Liberar da barra de tarefas"</string>
 </resources>
diff --git a/quickstep/res/values-ro/strings.xml b/quickstep/res/values-ro/strings.xml
index 08e4081..3be5fcc 100644
--- a/quickstep/res/values-ro/strings.xml
+++ b/quickstep/res/values-ro/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Meniu suplimentar pentru bara de activități"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Mută în stânga sus"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Mută în dreapta jos"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Deschide aplicația ca balon"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{aplicație suplimentară}few{mai multe aplicații}other{mai multe aplicații}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Computer"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> și <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Balon"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Suplimentar"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> de la <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Pictograma aplicației"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Titlul aplicației"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Buton de închidere"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Fixează pe bara de activități"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Anulează fixarea din bara de activități"</string>
 </resources>
diff --git a/quickstep/res/values-ru/strings.xml b/quickstep/res/values-ru/strings.xml
index 65af36f..8129585 100644
--- a/quickstep/res/values-ru/strings.xml
+++ b/quickstep/res/values-ru/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Дополнительное меню панели задач"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Переместить вверх или влево"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Переместить вниз или вправо"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Открыть приложение во всплывающем окне"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{дополнительное приложение}one{дополнительное приложение}few{дополнительных приложения}many{дополнительных приложений}other{дополнительного приложения}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Режим компьютера"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> и <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Всплывающая подсказка"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Дополнительное меню"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"\"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g>\" из приложения \"<xliff:g id="APP_NAME">%2$s</xliff:g>\""</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Значок приложения"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Название приложения"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Кнопка \"Закрыть\""</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Закрепить на панели"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Открепить от панели"</string>
 </resources>
diff --git a/quickstep/res/values-si/strings.xml b/quickstep/res/values-si/strings.xml
index 7e00beb..2d6a3b9 100644
--- a/quickstep/res/values-si/strings.xml
+++ b/quickstep/res/values-si/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"කාර්ය තීරුව පිටාර යාම"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"ඉහළ/වම වෙත ගෙන යන්න"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"පහළ/දකුණ වෙත ගෙන යන්න"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"යෙදුම බුබුලක් ලෙස විවෘත කරන්න"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{තව යෙදුම}one{තවත් යෙදුම්}other{තවත් යෙදුම්}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"ඩෙස්ක්ටොපය"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> සහ <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"බුබුළු"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"පිටාර යාම"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="APP_NAME">%2$s</xliff:g> සිට <xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"යෙදුම් නිරූපකය"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"යෙදුම් මාතෘකාව"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"වැසීමේ බොත්තම"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"කාර්ය තීරුවට අමුණන්න"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"කාර්ය තීරුවෙන් ඉවත් කරන්න"</string>
 </resources>
diff --git a/quickstep/res/values-sk/strings.xml b/quickstep/res/values-sk/strings.xml
index 1170e71..e3a86cb 100644
--- a/quickstep/res/values-sk/strings.xml
+++ b/quickstep/res/values-sk/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Rozšírená ponuka panela aplikácií"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Presunúť hore alebo doľava"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Presunúť dole alebo doprava"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Otvoriť aplikáciu ako bublinu"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{ďalšia aplikácia}few{ďalšie aplikácie}many{ďalšie aplikácie}other{ďalšie aplikácie}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Počítač"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> a <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Bublina"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Rozbaľovacia ponuka"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> z aplikácie <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Ikona aplikácie"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Názov aplikácie"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Tlačidlo Zavrieť"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Pripnúť na panel"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Odopnúť z panela"</string>
 </resources>
diff --git a/quickstep/res/values-sl/strings.xml b/quickstep/res/values-sl/strings.xml
index 9ed661c..1f87e65 100644
--- a/quickstep/res/values-sl/strings.xml
+++ b/quickstep/res/values-sl/strings.xml
@@ -140,9 +140,16 @@
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Premakni na vrh/levo"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Premakni na dno/desno"</string>
     <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Odpri aplikacijo kot oblaček"</string>
+    <string name="quick_switch_pane_title" msgid="4677158207760585812">"Nedavne aplikacije"</string>
+    <string name="quick_switch_content_description" msgid="2851244536728720005">"Seznam nedavnih aplikacij"</string>
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{dodatna aplikacija}one{dodatna aplikacija}two{dodatni aplikaciji}few{dodatne aplikacije}other{dodatnih aplikacij}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Namizni računalnik"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> in <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <string name="quick_switch_task_with_position_in_parent" msgid="4968670948331508951">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, element <xliff:g id="INDEX_IN_PARENT">%2$d</xliff:g> od <xliff:g id="TOTAL_TASKS">%3$d</xliff:g>"</string>
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Oblaček"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Oblaček z dodatnimi elementi"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> iz aplikacije <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
diff --git a/quickstep/res/values-sq/strings.xml b/quickstep/res/values-sq/strings.xml
index 965699d..0bea11d 100644
--- a/quickstep/res/values-sq/strings.xml
+++ b/quickstep/res/values-sq/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Tejkalimi i shiritit të detyrave"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Lëviz në krye/majtas"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Lëviz në fund/djathtas"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Hap aplikacionin si një flluskë"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{aplikacion tjetër}other{aplikacione të tjera}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Desktop"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> dhe <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Flluska"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Tejkalimi"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"\"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g>\" nga <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Ikona e aplikacionit"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Titulli i aplikacionit"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Butoni i mbylljes"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Gozhdo te shiriti"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Zhgozhdo nga shiriti"</string>
 </resources>
diff --git a/quickstep/res/values-sr/strings.xml b/quickstep/res/values-sr/strings.xml
index c827cda..06ca295 100644
--- a/quickstep/res/values-sr/strings.xml
+++ b/quickstep/res/values-sr/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Преклопна трака задатака"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Премести горе лево"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Премести доле десно"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Отвори апликацију као облачић"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{додатна апликација}one{додатна апликација}few{додатне апликације}other{додатних апликација}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Рачунар"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> и <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Облачић"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Преклопни"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> – <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Икона апликације"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Назив апликације"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Дугме Затвори"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Закачи за траку зад."</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Откачи са траке зад."</string>
 </resources>
diff --git a/quickstep/res/values-sv/strings.xml b/quickstep/res/values-sv/strings.xml
index 5713036..8f57cad 100644
--- a/quickstep/res/values-sv/strings.xml
+++ b/quickstep/res/values-sv/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Fler alternativ för aktivitetsfältet"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Flytta högst upp/till vänster"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Flytta längst ned/till höger"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Öppna appen som en bubbla"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{app till}other{appar till}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Skrivbordsläge"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> och <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Bubbla"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Fler alternativ"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> från <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Appikon"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Apptitel"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Knappen Stäng"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Fäst i aktivitetsfält"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Lossa från aktivitetsfält"</string>
 </resources>
diff --git a/quickstep/res/values-sw/strings.xml b/quickstep/res/values-sw/strings.xml
index f1dbcbc..7aaf14e 100644
--- a/quickstep/res/values-sw/strings.xml
+++ b/quickstep/res/values-sw/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Upauzana wa Vipengele vya Ziada"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Sogeza juu/kushoto"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Sogeza chini/kulia"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Fungua programu kama kiputo"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{programu nyingine}other{programu zingine}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Kompyuta ya Mezani"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> na <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Kiputo"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Kiputo cha vipengee vya ziada"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> kutoka <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Aikoni ya programu"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Kichwa cha programu"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Kitufe cha kufunga"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Bandika kwa upauzana"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Bandua kwa upauzana"</string>
 </resources>
diff --git a/quickstep/res/values-ta/strings.xml b/quickstep/res/values-ta/strings.xml
index 04dfc30..b0b771e 100644
--- a/quickstep/res/values-ta/strings.xml
+++ b/quickstep/res/values-ta/strings.xml
@@ -90,7 +90,7 @@
     <string name="allset_title" msgid="5021126669778966707">"அனைத்தையும் அமைத்துவிட்டீர்கள்!"</string>
     <string name="allset_hint" msgid="459504134589971527">"முகப்புக்குச் செல்ல மேல்நோக்கி ஸ்வைப் செய்யுங்கள்"</string>
     <string name="allset_button_hint" msgid="2395219947744706291">"முகப்புத் திரைக்குச் செல்வதற்கு முகப்பு பட்டனைத் தட்டவும்"</string>
-    <string name="allset_description_generic" msgid="5385500062202019855">"உங்கள் <xliff:g id="DEVICE">%1$s</xliff:g> ஐப் பயன்படுத்தத் தயாராகிவிட்டீர்கள்"</string>
+    <string name="allset_description_generic" msgid="5385500062202019855">"உங்கள் <xliff:g id="DEVICE">%1$s</xliff:g> உங்களுக்காகத் தயாராக இருக்கிறது"</string>
     <string name="default_device_name" msgid="6660656727127422487">"சாதனம்"</string>
     <string name="allset_navigation_settings" msgid="4713404605961476027"><annotation id="link">"சிஸ்டம் வழிசெலுத்தல் அமைப்புகள்"</annotation></string>
     <string name="action_share" msgid="2648470652637092375">"பகிர்"</string>
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"செயல் பட்டிக்கான கூடுதல் விருப்பங்கள்"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"மேலே/இடதுபுறம் நகர்த்தும்"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"கீழே/வலதுபுறம் நகர்த்தும்"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"ஆப்ஸைக் குமிழாகத் திற"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{கூடுதல் ஆப்ஸ்}other{கூடுதல் ஆப்ஸ்}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"டெஸ்க்டாப்"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> மற்றும் <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"குமிழ்"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"கூடுதல் விருப்பங்களைக் காட்டும்"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="APP_NAME">%2$s</xliff:g> வழங்கும் <xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"ஆப்ஸ் ஐகான்"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"ஆப்ஸ் தலைப்பு"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"மூடுவதற்கான பட்டன்"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"செயல்பட்டியில் பின் செய்"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"செயல்பட்டியிலிருந்து அகற்று"</string>
 </resources>
diff --git a/quickstep/res/values-te/strings.xml b/quickstep/res/values-te/strings.xml
index 516c2f7..5f0e7a4 100644
--- a/quickstep/res/values-te/strings.xml
+++ b/quickstep/res/values-te/strings.xml
@@ -140,9 +140,19 @@
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"ఎగువ/ఎడమ వైపునకు తరలించండి"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"దిగువ/కుడి వైపునకు తరలించండి"</string>
     <string name="open_app_as_a_bubble" msgid="6642626287247807473">"యాప్‌ను బబుల్‌లాగా తెరవండి"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
+    <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{మరో యాప్‌}other{మరిన్ని యాప్‌లు}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"డెస్క్‌టాప్"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g>, <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"బబుల్"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"ఓవర్‌ఫ్లో"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="APP_NAME">%2$s</xliff:g> నుండి <xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g>"</string>
diff --git a/quickstep/res/values-th/strings.xml b/quickstep/res/values-th/strings.xml
index 04eac38..9a88f92 100644
--- a/quickstep/res/values-th/strings.xml
+++ b/quickstep/res/values-th/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"การดำเนินการเพิ่มเติมของแถบงาน"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"ย้ายไปที่ด้านบนหรือด้านซ้าย"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"ย้ายไปที่ด้านล่างหรือด้านขวา"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"เปิดแอปเป็นบับเบิล"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{แอปเพิ่มเติม}other{แอปเพิ่มเติม}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"เดสก์ท็อป"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> และ <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"บับเบิล"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"การดำเนินการเพิ่มเติม"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> จาก <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"ไอคอนแอป"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"ชื่อแอป"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"ปุ่มปิด"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"ปักหมุดไปยังแถบงาน"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"เลิกปักหมุดจากแถบงาน"</string>
 </resources>
diff --git a/quickstep/res/values-tl/strings.xml b/quickstep/res/values-tl/strings.xml
index 89ead25..f85cce4 100644
--- a/quickstep/res/values-tl/strings.xml
+++ b/quickstep/res/values-tl/strings.xml
@@ -140,9 +140,19 @@
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Ilipat sa itaas/kaliwa"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Ilipat sa ibaba/kanan"</string>
     <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Buksan ang app bilang bubble"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
+    <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{pang app}one{pang app}other{pang app}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Desktop"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> at <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Bubble"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Overflow"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> mula sa <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
diff --git a/quickstep/res/values-tr/strings.xml b/quickstep/res/values-tr/strings.xml
index f2c42d0..c39a65f 100644
--- a/quickstep/res/values-tr/strings.xml
+++ b/quickstep/res/values-tr/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Görev Çubuğu Taşması"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Sol üste taşı"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Sağ alta taşı"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Uygulamayı balon olarak aç"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{uygulama daha}other{uygulama daha}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Masaüstü"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> ve <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Balon"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Taşma"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="APP_NAME">%2$s</xliff:g> uygulamasından <xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Uygulama simgesi"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Uygulama başlığı"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Kapat düğmesi"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Çubuğa sabitle"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Çubuktan kaldır"</string>
 </resources>
diff --git a/quickstep/res/values-uk/strings.xml b/quickstep/res/values-uk/strings.xml
index 82d8a60..433e020 100644
--- a/quickstep/res/values-uk/strings.xml
+++ b/quickstep/res/values-uk/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Додаткове меню панелі завдань"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Перемістити вгору або вліво"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Перемістити вниз або вправо"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Відкрити додаток у спливаючому вікні"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{інший додаток}one{інший додаток}few{інші додатки}many{інших додатків}other{іншого додатка}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Комп’ютер"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> та <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Повідомлення"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Додаткове повідомлення"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> з додатка <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Значок додатка"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Назва додатка"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Кнопка \"Закрити\""</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"На панель завдань"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"З панелі завдань"</string>
 </resources>
diff --git a/quickstep/res/values-ur/strings.xml b/quickstep/res/values-ur/strings.xml
index 65436ae..603760c 100644
--- a/quickstep/res/values-ur/strings.xml
+++ b/quickstep/res/values-ur/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"ٹاسک بار اوورفلو"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"اوپر/بائیں طرف منتقل کریں"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"نیچے/دائیں طرف منتقل کریں"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"ایپ کو بطور ببل کھولیں"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{مزید ایپ}other{مزید ایپس}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"ڈیسک ٹاپ"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> اور <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"ببل"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"اوورفلو"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="APP_NAME">%2$s</xliff:g> سے <xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"ایپ آئیکن"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"ایپ کا عنوان"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"\'بند کریں\' بٹن"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"ٹاسک بار میں پن کریں"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"ٹاسک بار سے پن ہٹائیں"</string>
 </resources>
diff --git a/quickstep/res/values-uz/strings.xml b/quickstep/res/values-uz/strings.xml
index b761b5d..f289573 100644
--- a/quickstep/res/values-uz/strings.xml
+++ b/quickstep/res/values-uz/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Vazifalar panelini kengaytirish"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Yuqoriga yoki chapga oʻtkazish"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Pastga yoki oʻngga oʻtkazish"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Ilovani qalqib chiquvchi oynada ochish"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{boshqa ilova}other{boshqa ilovalar}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Kompyuter"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> va <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Pufak"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Kengaytirish"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> (<xliff:g id="APP_NAME">%2$s</xliff:g>)"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Ilova belgisi"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Ilova nomi"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Yopish tugmasi"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Panelga qadash"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Vazifalar panelidan yechib olish"</string>
 </resources>
diff --git a/quickstep/res/values-vi/strings.xml b/quickstep/res/values-vi/strings.xml
index 383f915..d0f5252 100644
--- a/quickstep/res/values-vi/strings.xml
+++ b/quickstep/res/values-vi/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Trình đơn mục bổ sung trên thanh tác vụ"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Chuyển lên trên cùng/sang bên trái"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Chuyển xuống dưới cùng/sang bên phải"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Mở ứng dụng dưới dạng bong bóng"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{ứng dụng khác}other{ứng dụng khác}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Máy tính"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g> và <xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Bong bóng"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Bong bóng bổ sung"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> từ <xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Biểu tượng ứng dụng"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Tên ứng dụng"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Nút đóng"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Ghim vào thanh tác vụ"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Bỏ ghim khỏi thanh tác vụ"</string>
 </resources>
diff --git a/quickstep/res/values-zh-rCN/strings.xml b/quickstep/res/values-zh-rCN/strings.xml
index 17d022e..6548148 100644
--- a/quickstep/res/values-zh-rCN/strings.xml
+++ b/quickstep/res/values-zh-rCN/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"任务栏溢出图标"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"移到顶部/左侧"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"移到底部/右侧"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"以气泡的形式打开应用"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{多个应用}other{多个应用}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"桌面模式"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"<xliff:g id="APP_NAME_1">%1$s</xliff:g>和<xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"气泡框"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"溢出式气泡框"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"来自“<xliff:g id="APP_NAME">%2$s</xliff:g>”的<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"应用图标"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"应用名称"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"“关闭”按钮"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"固定到任务栏"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"从任务栏取消固定"</string>
 </resources>
diff --git a/quickstep/res/values-zh-rHK/strings.xml b/quickstep/res/values-zh-rHK/strings.xml
index 47bb6d4..0606463 100644
--- a/quickstep/res/values-zh-rHK/strings.xml
+++ b/quickstep/res/values-zh-rHK/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"工作列溢位"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"移至上方/左側"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"移至底部/右側"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"在小視窗開啟應用程式"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{個其他應用程式}other{個其他應用程式}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"桌面"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"「<xliff:g id="APP_NAME_1">%1$s</xliff:g>」和「<xliff:g id="APP_NAME_2">%2$s</xliff:g>」"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"對話氣泡"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"展開式"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="APP_NAME">%2$s</xliff:g> 的「<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g>」通知"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"應用程式圖示"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"應用程式名稱"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"關閉按鈕"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"固定至工作列"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"取消固定至工作列"</string>
 </resources>
diff --git a/quickstep/res/values-zh-rTW/strings.xml b/quickstep/res/values-zh-rTW/strings.xml
index 58c7bb5..44c6fdf 100644
--- a/quickstep/res/values-zh-rTW/strings.xml
+++ b/quickstep/res/values-zh-rTW/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"工作列溢位"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"移到上方/左側"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"移到底部/右側"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"以泡泡形式開啟應用程式"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{個其他應用程式}other{個其他應用程式}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"電腦模式"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"「<xliff:g id="APP_NAME_1">%1$s</xliff:g>」和「<xliff:g id="APP_NAME_2">%2$s</xliff:g>」"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"泡泡"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"溢位"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"「<xliff:g id="APP_NAME">%2$s</xliff:g>」的「<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g>」通知"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"應用程式圖示"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"應用程式標題"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"關閉按鈕"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"固定到工作列"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"從工作列中取消固定"</string>
 </resources>
diff --git a/quickstep/res/values-zu/strings.xml b/quickstep/res/values-zu/strings.xml
index 8d0a6db..c666ee7 100644
--- a/quickstep/res/values-zu/strings.xml
+++ b/quickstep/res/values-zu/strings.xml
@@ -139,11 +139,20 @@
     <string name="taskbar_overflow_a11y_title" msgid="7960342079198820179">"Ukuphuphuma Kwetaskbar"</string>
     <string name="move_drop_target_top_or_left" msgid="2988702185049595807">"Hamba phezulu/kwesokunxele"</string>
     <string name="move_drop_target_bottom_or_right" msgid="5431393418797620162">"Hamba phansi/kwesokudla"</string>
-    <!-- no translation found for open_app_as_a_bubble (6642626287247807473) -->
+    <string name="open_app_as_a_bubble" msgid="6642626287247807473">"Vula i-app njengebhamuza"</string>
+    <!-- no translation found for quick_switch_pane_title (4677158207760585812) -->
+    <skip />
+    <!-- no translation found for quick_switch_content_description (2851244536728720005) -->
     <skip />
     <string name="quick_switch_overflow" msgid="3679780650881041632">"{count,plural, =1{i-app eyengeziwe}one{ama-app engeziwe}other{ama-app engeziwe}}"</string>
     <string name="quick_switch_desktop" msgid="8393802056024499749">"Ideskithophu"</string>
     <string name="quick_switch_split_task" msgid="5598194724255333896">"I-<xliff:g id="APP_NAME_1">%1$s</xliff:g> ne-<xliff:g id="APP_NAME_2">%2$s</xliff:g>"</string>
+    <!-- no translation found for quick_switch_task_with_position_in_parent (4968670948331508951) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_left (6527033155534184309) -->
+    <skip />
+    <!-- no translation found for quick_switch_scroll_arrow_right (7319779291086916348) -->
+    <skip />
     <string name="bubble_bar_bubble_fallback_description" msgid="7811684548953452009">"Ibhamuza"</string>
     <string name="bubble_bar_overflow_description" msgid="8617628132733151708">"Ukugcwala kakhulu"</string>
     <string name="bubble_bar_bubble_description" msgid="1882466152448446446">"<xliff:g id="NOTIFICATION_TITLE">%1$s</xliff:g> kusuka ku-<xliff:g id="APP_NAME">%2$s</xliff:g>"</string>
@@ -157,8 +166,6 @@
     <string name="header_app_icon_description" msgid="2184625881433608027">"Isithonjana se-app"</string>
     <string name="header_default_app_title" msgid="8308052350689531566">"Isihloko se-app"</string>
     <string name="header_close_icon_description" msgid="5400033616675911319">"Inkinobho yokuvala"</string>
-    <!-- no translation found for pin_to_taskbar (6607778046321626950) -->
-    <skip />
-    <!-- no translation found for unpin_from_taskbar (2178811773165572676) -->
-    <skip />
+    <string name="pin_to_taskbar" msgid="6607778046321626950">"Phina kutaskbar"</string>
+    <string name="unpin_from_taskbar" msgid="2178811773165572676">"Susa ukuphina i-taskbar"</string>
 </resources>
diff --git a/quickstep/res/values/config.xml b/quickstep/res/values/config.xml
index e69fa4d..49cee0f 100644
--- a/quickstep/res/values/config.xml
+++ b/quickstep/res/values/config.xml
@@ -23,7 +23,6 @@
 
     <string name="stats_log_manager_class" translatable="false">com.android.quickstep.logging.StatsLogCompatManager</string>
     <string name="test_information_handler_class" translatable="false">com.android.quickstep.QuickstepTestInformationHandler</string>
-    <string name="widget_holder_factory_class" translatable="false">com.android.launcher3.uioverrides.QuickstepWidgetHolder$QuickstepHolderFactory</string>
     <string name="instant_app_resolver_class" translatable="false">com.android.quickstep.InstantAppResolverImpl</string>
     <string name="app_launch_tracker_class" translatable="false">com.android.launcher3.appprediction.PredictionAppTracker</string>
     <string name="main_process_initializer_class" translatable="false">com.android.quickstep.QuickstepProcessInitializer</string>
@@ -47,6 +46,7 @@
     <string name="wellbeing_provider_pkg" translatable="false"/>
 
     <integer name="max_depth_blur_radius">23</integer>
+    <dimen name="max_depth_blur_radius_enhanced">34dp</dimen>
 
     <!-- If predicted widgets from prediction service are less than this number, additional
     eligible widgets may be added locally by launcher. When set to 0, no widgets will be added
diff --git a/quickstep/res/values/dimens.xml b/quickstep/res/values/dimens.xml
index 36e6902..cb3c446 100644
--- a/quickstep/res/values/dimens.xml
+++ b/quickstep/res/values/dimens.xml
@@ -82,9 +82,9 @@
     <dimen name="task_thumbnail_icon_menu_drawable_touch_size">44dp</dimen>
     <dimen name="task_thumbnail_icon_menu_elevation">4dp</dimen>
     <!--  The size of the task thumbnail header  -->
-    <dimen name="task_thumbnail_header_height">30dp</dimen>
-    <dimen name="task_thumbnail_header_margin_edge">18dp</dimen>
-    <dimen name="task_thumbnail_header_margin_between_views">9dp</dimen>
+    <dimen name="task_thumbnail_header_padding_top_bottom">6dp</dimen>
+    <dimen name="task_thumbnail_header_padding_start_end">12dp</dimen>
+    <dimen name="task_thumbnail_header_margin_between_views">8dp</dimen>
     <dimen name="task_thumbnail_header_icon_size">18dp</dimen>
     <dimen name="task_thumbnail_header_round_corner_radius">16dp</dimen>
 
@@ -363,6 +363,7 @@
     <dimen name="taskbar_home_button_left_margin_kids">48dp</dimen>
     <dimen name="taskbar_icon_size_kids">32dp</dimen>
     <dimen name="taskbar_all_apps_search_button_translation_x_offset">6dp</dimen>
+    <dimen name="taskbar_all_apps_search_button_translation_x_offset_for_expressive_theme">5.5dp</dimen>
     <dimen name="taskbar_contextual_button_suw_margin">64dp</dimen>
     <dimen name="taskbar_contextual_button_suw_height">64dp</dimen>
     <dimen name="taskbar_back_button_suw_start_margin">48dp</dimen>
@@ -381,6 +382,7 @@
     <dimen name="transient_taskbar_key_shadow_distance">10dp</dimen>
     <dimen name="transient_taskbar_stashed_height">32dp</dimen>
     <dimen name="transient_taskbar_all_apps_button_translation_x_offset">8dp</dimen>
+    <dimen name="transient_taskbar_all_apps_button_translation_x_offset_for_expressive_theme">8dp</dimen>
     <dimen name="transient_taskbar_stash_spring_velocity_dp_per_s">400dp</dimen>
     <dimen name="taskbar_tooltip_vertical_padding">8dp</dimen>
     <dimen name="taskbar_tooltip_horizontal_padding">16dp</dimen>
@@ -459,7 +461,8 @@
     <!-- Container size with pointer included: bubblebar_size + bubblebar_pointer_size -->
     <dimen name="bubblebar_size_with_pointer">80dp</dimen>
     <dimen name="bubblebar_elevation">1dp</dimen>
-    <dimen name="bubblebar_drag_elevation">2dp</dimen>
+    <!-- TODO b/396539130: used wmshared value once resources are fixed -->
+    <dimen name="dragged_bubble_elevation">3dp</dimen>
     <dimen name="bubblebar_hotseat_adjustment_threshold">90dp</dimen>
     <dimen name="bubblebar_bounce_distance">20dp</dimen>
 
@@ -510,7 +513,8 @@
     <dimen name="starting_surface_exit_animation_window_shift_length">20dp</dimen>
 
     <!-- Keyboard Quick Switch -->
-    <dimen name="keyboard_quick_switch_border_width">4dp</dimen>
+    <dimen name="keyboard_quick_switch_border_width">5dp</dimen>
+    <dimen name="keyboard_quick_switch_border_stroke">3dp</dimen>
     <dimen name="keyboard_quick_switch_taskview_width">104dp</dimen>
     <dimen name="keyboard_quick_switch_taskview_height">136dp</dimen>
     <dimen name="keyboard_quick_switch_taskview_icon_size">52dp</dimen>
@@ -531,8 +535,8 @@
     <dimen name="keyboard_quick_switch_text_button_fade_edge_length">20dp</dimen>
     <dimen name="keyboard_quick_switch_scroll_button_width">36dp</dimen>
     <dimen name="keyboard_quick_switch_scroll_button_height">56dp</dimen>
-    <dimen name="keyboard_quick_switch_scroll_button_horizontal_padding">12dp</dimen>
-    <dimen name="keyboard_quick_switch_scroll_button_vertical_padding">32dp</dimen>
+    <dimen name="keyboard_quick_switch_scroll_button_horizontal_padding">6dp</dimen>
+    <dimen name="keyboard_quick_switch_scroll_button_vertical_padding">16dp</dimen>
     <dimen name="keyboard_quick_switch_scroll_button_corner_radius">18dp</dimen>
 
     <!-- Digital Wellbeing -->
diff --git a/quickstep/res/values/strings.xml b/quickstep/res/values/strings.xml
index 7578bd5..f263f7e 100644
--- a/quickstep/res/values/strings.xml
+++ b/quickstep/res/values/strings.xml
@@ -345,12 +345,10 @@
     <!-- Accessibility label for quick switch tiles that include information about the tile's position in the parent list [CHAR LIMIT=NONE] -->
     <string name="quick_switch_task_with_position_in_parent"><xliff:g id="task_description" example="Chrome">%1$s</xliff:g>, item <xliff:g id="index_in_parent" example="1">%2$d</xliff:g> of <xliff:g id="total_tasks" example="5">%3$d</xliff:g></string>
 
-    <!-- Accessibility label for an arrow button within quick switch UI that scrolls the quick switch content left
-        TODO(b/397975686): Make these translatable when verified by UX. -->
-    <string name="quick_switch_scroll_arrow_left" translatable="false">Scroll left</string>
-    <!-- Accessibility label for an arrow button within quick switch UI that scrolls the quick switch content right
-        TODO(b/397975686): Make these translatable when verified by UX. -->
-    <string name="quick_switch_scroll_arrow_right" translatable="false">Scroll right</string>
+    <!-- Accessibility label for an arrow button within quick switch UI that scrolls the quick switch content left -->
+    <string name="quick_switch_scroll_arrow_left">Scroll left</string>
+    <!-- Accessibility label for an arrow button within quick switch UI that scrolls the quick switch content right -->
+    <string name="quick_switch_scroll_arrow_right">Scroll right</string>
 
     <!-- Strings for bubble bar -->
     <!-- Fallback name for a bubble if it does have a title [CHAR_LIMIT=none] -->
diff --git a/quickstep/src/com/android/launcher3/QuickstepTransitionManager.java b/quickstep/src/com/android/launcher3/QuickstepTransitionManager.java
index aae8a56..21af26e 100644
--- a/quickstep/src/com/android/launcher3/QuickstepTransitionManager.java
+++ b/quickstep/src/com/android/launcher3/QuickstepTransitionManager.java
@@ -40,12 +40,14 @@
 import static com.android.app.animation.Interpolators.DECELERATE_1_7;
 import static com.android.app.animation.Interpolators.EXAGGERATED_EASE;
 import static com.android.app.animation.Interpolators.LINEAR;
+import static com.android.launcher3.BaseActivity.EVENT_DESTROYED;
 import static com.android.launcher3.BaseActivity.INVISIBLE_ALL;
 import static com.android.launcher3.BaseActivity.INVISIBLE_BY_APP_TRANSITIONS;
 import static com.android.launcher3.BaseActivity.INVISIBLE_BY_PENDING_FLAGS;
 import static com.android.launcher3.BaseActivity.PENDING_INVISIBLE_BY_WALLPAPER_ANIMATION;
 import static com.android.launcher3.Flags.enableContainerReturnAnimations;
 import static com.android.launcher3.Flags.enableScalingRevealHomeAnimation;
+import static com.android.launcher3.Flags.syncAppLaunchWithTaskbarStash;
 import static com.android.launcher3.LauncherAnimUtils.SCALE_PROPERTY;
 import static com.android.launcher3.LauncherState.ALL_APPS;
 import static com.android.launcher3.LauncherState.BACKGROUND_APP;
@@ -92,6 +94,7 @@
 import android.os.SystemProperties;
 import android.os.UserHandle;
 import android.provider.Settings;
+import android.util.Log;
 import android.util.Pair;
 import android.util.Size;
 import android.view.CrossWindowBlurListeners;
@@ -182,6 +185,7 @@
  * Manages the opening and closing app transitions from Launcher
  */
 public class QuickstepTransitionManager implements OnDeviceProfileChangeListener {
+    private static final String TAG = "QuickstepTransitionManager";
 
     private static final boolean ENABLE_SHELL_STARTING_SURFACE =
             SystemProperties.getBoolean("persist.debug.shell_starting_surface", true);
@@ -356,6 +360,20 @@
         options.setOnAnimationAbortListener(endCallback);
         options.setOnAnimationFinishedListener(endCallback);
         options.setLaunchCookie(StableViewInfo.toLaunchCookie(itemInfo));
+
+        // Prepare taskbar for animation synchronization. This needs to happen here before any
+        // app transition is created.
+        LauncherTaskbarUIController taskbarController = mLauncher.getTaskbarUIController();
+        if (syncAppLaunchWithTaskbarStash()
+                && enableScalingRevealHomeAnimation()
+                && taskbarController != null) {
+            taskbarController.setIgnoreInAppFlagForSync(true);
+            mLauncher.addEventCallback(EVENT_DESTROYED, onEndCallback::executeAllAndDestroy);
+            onEndCallback.add(() -> {
+                taskbarController.setIgnoreInAppFlagForSync(false);
+            });
+        }
+
         return new ActivityOptionsWrapper(options, onEndCallback);
     }
 
@@ -1207,7 +1225,7 @@
         mLauncher.removeOnDeviceProfileChangeListener(this);
         SystemUiProxy.INSTANCE.get(mLauncher).setStartingWindowListener(null);
         if (BuildConfig.IS_STUDIO_BUILD && !mRegisteredTaskStackChangeListener.isEmpty()) {
-            throw new IllegalStateException("Failed to run onEndCallback created from"
+            Log.e(TAG, "IllegalState: Failed to run onEndCallback created from"
                     + " getActivityLaunchOptions()");
         }
         mRegisteredTaskStackChangeListener.forEach(TaskRestartedDuringLaunchListener::unregister);
@@ -1903,6 +1921,21 @@
                 anim.addListener(mForceInvisibleListener);
             }
 
+            // Syncs the app launch animation and taskbar stash animation (if exists).
+            if (syncAppLaunchWithTaskbarStash() && enableScalingRevealHomeAnimation()) {
+                LauncherTaskbarUIController taskbarController = mLauncher.getTaskbarUIController();
+                if (taskbarController != null) {
+                    taskbarController.setIgnoreInAppFlagForSync(false);
+
+                    if (launcherClosing) {
+                        Animator taskbar = taskbarController.createAnimToApp();
+                        if (taskbar != null) {
+                            anim.play(taskbar);
+                        }
+                    }
+                }
+            }
+
             result.setAnimation(anim, mLauncher, mOnEndCallback::executeAllAndDestroy,
                     skipFirstFrame);
         }
diff --git a/quickstep/src/com/android/launcher3/WidgetPickerActivity.java b/quickstep/src/com/android/launcher3/WidgetPickerActivity.java
index 4d3e3be..cdae9ca 100644
--- a/quickstep/src/com/android/launcher3/WidgetPickerActivity.java
+++ b/quickstep/src/com/android/launcher3/WidgetPickerActivity.java
@@ -166,7 +166,7 @@
         mApp = LauncherAppState.getInstance(this);
         InvariantDeviceProfile idp = mApp.getInvariantDeviceProfile();
         mDeviceProfile = idp.getDeviceProfile(this);
-        mModel = new WidgetsModel();
+        mModel = new WidgetsModel(mApp.getContext());
         mWidgetPickerDataProvider = new WidgetPickerDataProvider(this);
 
         setContentView(R.layout.widget_picker_activity);
@@ -309,8 +309,7 @@
      */
     private void refreshAndBindWidgets() {
         MODEL_EXECUTOR.execute(() -> {
-            LauncherAppState app = LauncherAppState.getInstance(this);
-            mModel.update(app, null);
+            mModel.update(null);
 
             StringCache stringCache = new StringCache();
             stringCache.loadStrings(this);
@@ -321,9 +320,10 @@
             // animation.
             openWidgetsSheet();
             if (mUiSurface != null) {
-                mWidgetPredictionsRequester = new WidgetPredictionsRequester(app.getContext(),
-                        mUiSurface, mModel.getWidgetsByComponentKeyForPicker());
-                mWidgetPredictionsRequester.request(mAddedWidgets, /*listener=*/ this);
+                mWidgetPredictionsRequester = new WidgetPredictionsRequester(
+                        getApplicationContext(), mUiSurface,
+                        mModel.getWidgetsByComponentKeyForPicker());
+                mWidgetPredictionsRequester.request(mAddedWidgets, this);
             }
         });
     }
diff --git a/quickstep/src/com/android/launcher3/dagger/Modules.kt b/quickstep/src/com/android/launcher3/dagger/Modules.kt
index 52be413..7671a82 100644
--- a/quickstep/src/com/android/launcher3/dagger/Modules.kt
+++ b/quickstep/src/com/android/launcher3/dagger/Modules.kt
@@ -16,11 +16,13 @@
 
 package com.android.launcher3.dagger
 
+import com.android.launcher3.uioverrides.QuickstepWidgetHolder.QuickstepWidgetHolderFactory
 import com.android.launcher3.uioverrides.SystemApiWrapper
 import com.android.launcher3.uioverrides.plugins.PluginManagerWrapperImpl
 import com.android.launcher3.util.ApiWrapper
 import com.android.launcher3.util.PluginManagerWrapper
 import com.android.launcher3.util.window.WindowManagerProxy
+import com.android.launcher3.widget.LauncherWidgetHolder.WidgetHolderFactory
 import com.android.quickstep.util.GestureExclusionManager
 import com.android.quickstep.util.SystemWindowManagerProxy
 import dagger.Binds
@@ -40,6 +42,13 @@
 }
 
 @Module
+abstract class WidgetModule {
+
+    @Binds
+    abstract fun bindWidgetHolderFactory(factor: QuickstepWidgetHolderFactory): WidgetHolderFactory
+}
+
+@Module
 abstract class PluginManagerWrapperModule {
     @Binds
     abstract fun bindPluginManagerWrapper(impl: PluginManagerWrapperImpl): PluginManagerWrapper
diff --git a/quickstep/src/com/android/launcher3/desktop/DesktopAppLaunchAnimatorHelper.kt b/quickstep/src/com/android/launcher3/desktop/DesktopAppLaunchAnimatorHelper.kt
index 1438edf..a9e5145 100644
--- a/quickstep/src/com/android/launcher3/desktop/DesktopAppLaunchAnimatorHelper.kt
+++ b/quickstep/src/com/android/launcher3/desktop/DesktopAppLaunchAnimatorHelper.kt
@@ -93,7 +93,7 @@
         }
         if (trampolineCloseChange != null) {
             val trampolineCloseAnimator =
-                createTrampolineCloseAnimator(trampolineCloseChange, transaction)
+                createTrampolineCloseAnimator(trampolineCloseChange, transaction, finishCallback)
             animatorsList.add(trampolineCloseAnimator)
         }
         return animatorsList
@@ -112,7 +112,7 @@
     private fun getTrampolineCloseChange(info: TransitionInfo): Change? {
         if (
             info.changes.size < 2 ||
-                !DesktopModeFlags.ENABLE_DESKTOP_TRAMPOLINE_CLOSE_ANIMATION_BUGFIX.isTrue
+            !DesktopModeFlags.ENABLE_DESKTOP_TRAMPOLINE_CLOSE_ANIMATION_BUGFIX.isTrue
         ) {
             return null
         }
@@ -194,13 +194,22 @@
         )
     }
 
-    private fun createTrampolineCloseAnimator(change: Change, transaction: Transaction): Animator {
+    private fun createTrampolineCloseAnimator(
+        change: Change,
+        transaction: Transaction,
+        onAnimFinish: (Animator) -> Unit,
+    ): Animator {
         return ValueAnimator.ofFloat(1f, 0f).apply {
             duration = 100L
             interpolator = Interpolators.LINEAR
             addUpdateListener { animation ->
                 transaction.setAlpha(change.leash, animation.animatedValue as Float).apply()
             }
+            addListener(
+                onEnd = { animation ->
+                    onAnimFinish(animation)
+                }
+            )
         }
     }
 
diff --git a/quickstep/src/com/android/launcher3/model/PredictionUpdateTask.java b/quickstep/src/com/android/launcher3/model/PredictionUpdateTask.java
index fd71151..3544844 100644
--- a/quickstep/src/com/android/launcher3/model/PredictionUpdateTask.java
+++ b/quickstep/src/com/android/launcher3/model/PredictionUpdateTask.java
@@ -32,9 +32,9 @@
 import androidx.annotation.NonNull;
 
 import com.android.launcher3.ConstantItem;
-import com.android.launcher3.LauncherAppState;
 import com.android.launcher3.LauncherModel.ModelUpdateTask;
 import com.android.launcher3.LauncherPrefs;
+import com.android.launcher3.icons.IconCache;
 import com.android.launcher3.model.BgDataModel.FixedContainerItems;
 import com.android.launcher3.model.QuickstepModelDelegate.PredictorState;
 import com.android.launcher3.model.data.AppInfo;
@@ -65,8 +65,8 @@
     @Override
     public void execute(@NonNull ModelTaskController taskController, @NonNull BgDataModel dataModel,
             @NonNull AllAppsList apps) {
-        LauncherAppState app = taskController.getApp();
-        Context context = app.getContext();
+        IconCache iconCache = taskController.getIconCache();
+        Context context = taskController.getContext();
 
         // TODO: remove this
         LauncherPrefs.get(context).put(LAST_PREDICTION_ENABLED, !mTargets.isEmpty());
@@ -84,7 +84,7 @@
             if (si != null) {
                 usersForChangedShortcuts.add(si.getUserHandle());
                 itemInfo = new WorkspaceItemInfo(si, context);
-                app.getIconCache().getShortcutIcon(itemInfo, si);
+                iconCache.getShortcutIcon(itemInfo, si);
             } else {
                 String className = target.getClassName();
                 if (COMPONENT_CLASS_MARKER.equals(className)) {
@@ -96,7 +96,7 @@
                 itemInfo = apps.data.stream()
                         .filter(info -> user.equals(info.user) && cn.equals(info.componentName))
                         .map(ai -> {
-                            app.getIconCache().getTitleAndIcon(ai, mPredictorState.lookupFlag);
+                            iconCache.getTitleAndIcon(ai, mPredictorState.lookupFlag);
                             return ai.makeWorkspaceItem(context);
                         })
                         .findAny()
@@ -107,7 +107,7 @@
                                 return null;
                             }
                             AppInfo ai = new AppInfo(context, lai, user);
-                            app.getIconCache().getTitleAndIcon(ai, lai, DEFAULT_LOOKUP_FLAG);
+                            iconCache.getTitleAndIcon(ai, lai, DEFAULT_LOOKUP_FLAG);
                             return ai.makeWorkspaceItem(context);
                         });
 
@@ -123,8 +123,7 @@
         FixedContainerItems fci = new FixedContainerItems(mPredictorState.containerId, items);
         dataModel.extraItems.put(fci.containerId, fci);
         taskController.bindExtraContainerItems(fci);
-        usersForChangedShortcuts.forEach(
-                u -> dataModel.updateShortcutPinnedState(app.getContext(), u));
+        usersForChangedShortcuts.forEach(u -> dataModel.updateShortcutPinnedState(context, u));
 
         // Save to disk
         mPredictorState.storage.write(context, fci.items);
diff --git a/quickstep/src/com/android/launcher3/model/WidgetsPredictionUpdateTask.java b/quickstep/src/com/android/launcher3/model/WidgetsPredictionUpdateTask.java
index 0a4b7c8..da55b40 100644
--- a/quickstep/src/com/android/launcher3/model/WidgetsPredictionUpdateTask.java
+++ b/quickstep/src/com/android/launcher3/model/WidgetsPredictionUpdateTask.java
@@ -82,7 +82,7 @@
                                 && !widgetsInWorkspace.contains(entry.getValue())
                         ).collect(toMap(Map.Entry::getKey, Map.Entry::getValue));
 
-        Context context = taskController.getApp().getContext();
+        Context context = taskController.getContext();
 
         List<WidgetItem> servicePredictedItems = new ArrayList<>();
         List<String> addedWidgetApps = new ArrayList<>();
diff --git a/quickstep/src/com/android/launcher3/statehandlers/DepthController.java b/quickstep/src/com/android/launcher3/statehandlers/DepthController.java
index 4c24d95..360210b 100644
--- a/quickstep/src/com/android/launcher3/statehandlers/DepthController.java
+++ b/quickstep/src/com/android/launcher3/statehandlers/DepthController.java
@@ -65,7 +65,7 @@
     private void onLauncherDraw() {
         View view = mLauncher.getDragLayer();
         ViewRootImpl viewRootImpl = view.getViewRootImpl();
-        setSurface(viewRootImpl != null ? viewRootImpl.getSurfaceControl() : null);
+        setBaseSurface(viewRootImpl != null ? viewRootImpl.getSurfaceControl() : null);
         view.post(() -> view.getViewTreeObserver().removeOnDrawListener(mOnDrawListener));
     }
 
@@ -127,7 +127,7 @@
             mLauncher.getDragLayer().getViewTreeObserver().addOnDrawListener(mOnDrawListener);
         } else {
             mLauncher.getDragLayer().getViewTreeObserver().removeOnDrawListener(mOnDrawListener);
-            setSurface(null);
+            setBaseSurface(null);
         }
     }
 
@@ -189,7 +189,8 @@
         writer.println(prefix + "DepthController");
         writer.println(prefix + "\tmMaxBlurRadius=" + mMaxBlurRadius);
         writer.println(prefix + "\tmCrossWindowBlursEnabled=" + mCrossWindowBlursEnabled);
-        writer.println(prefix + "\tmSurface=" + mSurface);
+        writer.println(prefix + "\tmBaseSurface=" + mBaseSurface);
+        writer.println(prefix + "\tmBaseSurfaceOverride=" + mBaseSurfaceOverride);
         writer.println(prefix + "\tmStateDepth=" + stateDepth.getValue());
         writer.println(prefix + "\tmWidgetDepth=" + widgetDepth.getValue());
         writer.println(prefix + "\tmCurrentBlur=" + mCurrentBlur);
diff --git a/quickstep/src/com/android/launcher3/statehandlers/DesktopVisibilityController.kt b/quickstep/src/com/android/launcher3/statehandlers/DesktopVisibilityController.kt
index 2402a28..1ac2d7c 100644
--- a/quickstep/src/com/android/launcher3/statehandlers/DesktopVisibilityController.kt
+++ b/quickstep/src/com/android/launcher3/statehandlers/DesktopVisibilityController.kt
@@ -40,7 +40,8 @@
 import com.android.quickstep.fallback.RecentsState
 import com.android.wm.shell.desktopmode.DisplayDeskState
 import com.android.wm.shell.desktopmode.IDesktopTaskListener.Stub
-import com.android.wm.shell.shared.desktopmode.DesktopModeStatus
+import com.android.wm.shell.shared.desktopmode.DesktopModeStatus.enableMultipleDesktops
+import com.android.wm.shell.shared.desktopmode.DesktopModeStatus.useRoundedCorners
 import java.io.PrintWriter
 import java.lang.ref.WeakReference
 import javax.inject.Inject
@@ -89,8 +90,7 @@
     private val taskbarDesktopModeListeners: MutableSet<TaskbarDesktopModeListener> = HashSet()
 
     // This simply indicates that user is currently in desktop mode or not.
-    var isInDesktopMode = false
-        private set
+    @Deprecated("Does not work with multi-desks") private var isInDesktopModeDeprecated = false
 
     // to track if any pending notification to be done.
     var isNotifyingDesktopVisibilityPending = false
@@ -104,12 +104,16 @@
      * Number of visible desktop windows in desktop mode. This can be > 0 when user goes to overview
      * from desktop window mode.
      */
-    var visibleDesktopTasksCount: Int = 0
+    @Deprecated("Does not work with multi-desks")
+    var visibleDesktopTasksCountDeprecated: Int = 0
         /**
          * Sets the number of desktop windows that are visible and updates launcher visibility based
          * on it.
          */
         set(visibleTasksCount) {
+            if (enableMultipleDesktops(context)) {
+                return
+            }
             if (DEBUG) {
                 Log.d(
                     TAG,
@@ -121,11 +125,11 @@
             }
 
             if (visibleTasksCount != field) {
-                if (visibleDesktopTasksCount == 0 && visibleTasksCount == 1) {
-                    isInDesktopMode = true
+                if (visibleDesktopTasksCountDeprecated == 0 && visibleTasksCount == 1) {
+                    isInDesktopModeDeprecated = true
                 }
-                if (visibleDesktopTasksCount == 1 && visibleTasksCount == 0) {
-                    isInDesktopMode = false
+                if (visibleDesktopTasksCountDeprecated == 1 && visibleTasksCount == 0) {
+                    isInDesktopModeDeprecated = false
                 }
                 val wasVisible = field > 0
                 val isVisible = visibleTasksCount > 0
@@ -171,7 +175,7 @@
     private var desktopTaskListener: DesktopTaskListenerImpl?
 
     init {
-        desktopTaskListener = DesktopTaskListenerImpl(this, context.displayId)
+        desktopTaskListener = DesktopTaskListenerImpl(this, context, context.displayId)
         systemUiProxy.setDesktopTaskListener(desktopTaskListener)
 
         lifecycleTracker.addCloseable {
@@ -185,7 +189,7 @@
      * [INACTIVE_DESK_ID] if no desk is currently active or the multiple desks feature is disabled.
      */
     fun getActiveDeskId(displayId: Int): Int {
-        if (!DesktopModeStatus.enableMultipleDesktops(context)) {
+        if (!enableMultipleDesktops(context)) {
             // When the multiple desks feature is disabled, callers should not rely on the concept
             // of a desk ID.
             return INACTIVE_DESK_ID
@@ -196,8 +200,8 @@
 
     /** Returns whether a desk is currently active on the display with the given [displayId]. */
     fun isInDesktopMode(displayId: Int): Boolean {
-        if (!DesktopModeStatus.enableMultipleDesktops(context)) {
-            return isInDesktopMode
+        if (!enableMultipleDesktops(context)) {
+            return isInDesktopModeDeprecated
         }
 
         val activeDeskId = getDisplayDeskConfig(displayId)?.activeDeskId ?: INACTIVE_DESK_ID
@@ -213,7 +217,7 @@
      * Overview is not active.
      */
     fun isInDesktopModeAndNotInOverview(displayId: Int): Boolean {
-        if (!DesktopModeStatus.enableMultipleDesktops(context)) {
+        if (!enableMultipleDesktops(context)) {
             return areDesktopTasksVisibleAndNotInOverview()
         }
 
@@ -225,7 +229,7 @@
 
     /** Whether desktop tasks are visible in desktop mode. */
     private fun areDesktopTasksVisibleAndNotInOverview(): Boolean {
-        val desktopTasksVisible: Boolean = visibleDesktopTasksCount > 0
+        val desktopTasksVisible: Boolean = visibleDesktopTasksCountDeprecated > 0
         if (DEBUG) {
             Log.d(
                 TAG,
@@ -309,7 +313,7 @@
             inOverviewState = overviewStateEnabled
             val areDesktopTasksVisibleNow = areDesktopTasksVisibleAndNotInOverview()
 
-            if (!DesktopModeStatus.enableMultipleDesktops(context)) {
+            if (!enableMultipleDesktops(context)) {
                 if (wereDesktopTasksVisibleBefore != areDesktopTasksVisibleNow) {
                     notifyIsInDesktopModeChanged(DEFAULT_DISPLAY, areDesktopTasksVisibleNow)
                 }
@@ -504,7 +508,7 @@
         displayDeskStates: Array<DisplayDeskState>,
         canCreateDesks: Boolean,
     ) {
-        if (!DesktopModeStatus.enableMultipleDesktops(context)) {
+        if (!enableMultipleDesktops(context)) {
             return
         }
 
@@ -527,7 +531,7 @@
             ?: null.also { Slog.e(TAG, "Expected non-null desk config for display: $displayId") }
 
     private fun onCanCreateDesksChanged(canCreateDesks: Boolean) {
-        if (!DesktopModeStatus.enableMultipleDesktops(context)) {
+        if (!enableMultipleDesktops(context)) {
             return
         }
 
@@ -535,7 +539,7 @@
     }
 
     private fun onDeskAdded(displayId: Int, deskId: Int) {
-        if (!DesktopModeStatus.enableMultipleDesktops(context)) {
+        if (!enableMultipleDesktops(context)) {
             return
         }
 
@@ -549,7 +553,7 @@
     }
 
     private fun onDeskRemoved(displayId: Int, deskId: Int) {
-        if (!DesktopModeStatus.enableMultipleDesktops(context)) {
+        if (!enableMultipleDesktops(context)) {
             return
         }
 
@@ -566,7 +570,7 @@
     }
 
     private fun onActiveDeskChanged(displayId: Int, newActiveDesk: Int, oldActiveDesk: Int) {
-        if (!DesktopModeStatus.enableMultipleDesktops(context)) {
+        if (!enableMultipleDesktops(context)) {
             return
         }
 
@@ -626,7 +630,7 @@
         pw.println(prefix + "DesktopVisibilityController:")
 
         pw.println("$prefix\tdesktopVisibilityListeners=$desktopVisibilityListeners")
-        pw.println("$prefix\tvisibleDesktopTasksCount=$visibleDesktopTasksCount")
+        pw.println("$prefix\tvisibleDesktopTasksCount=$visibleDesktopTasksCountDeprecated")
         pw.println("$prefix\tinOverviewState=$inOverviewState")
         pw.println("$prefix\tbackgroundStateEnabled=$backgroundStateEnabled")
         pw.println("$prefix\tgestureInProgress=$gestureInProgress")
@@ -640,6 +644,7 @@
      */
     private class DesktopTaskListenerImpl(
         controller: DesktopVisibilityController,
+        @ApplicationContext private val context: Context,
         private val displayId: Int,
     ) : Stub() {
         private val controller = WeakReference(controller)
@@ -660,7 +665,7 @@
                     if (DEBUG) {
                         Log.d(TAG, "desktop visible tasks count changed=$visibleTasksCount")
                     }
-                    visibleDesktopTasksCount = visibleTasksCount
+                    visibleDesktopTasksCountDeprecated = visibleTasksCount
                 }
             }
         }
@@ -670,7 +675,7 @@
         }
 
         override fun onTaskbarCornerRoundingUpdate(doesAnyTaskRequireTaskbarRounding: Boolean) {
-            if (!DesktopModeStatus.useRoundedCorners()) return
+            if (!useRoundedCorners()) return
             MAIN_EXECUTOR.execute {
                 controller.get()?.apply {
                     Log.d(
@@ -683,7 +688,10 @@
             }
         }
 
+        // TODO: b/402496827 - The multi-desks backend needs to be updated to call this API only
+        //  once, not between desk switches.
         override fun onEnterDesktopModeTransitionStarted(transitionDuration: Int) {
+            val controller = controller.get() ?: return
             MAIN_EXECUTOR.execute {
                 Log.d(
                     TAG,
@@ -691,12 +699,19 @@
                         "duration= " +
                         transitionDuration),
                 )
-                controller.get()?.isInDesktopMode = true
-                controller.get()?.notifyTaskbarDesktopModeListenersForEntry(transitionDuration)
+                if (enableMultipleDesktops(context)) {
+                    controller.notifyTaskbarDesktopModeListenersForEntry(transitionDuration)
+                } else if (!controller.isInDesktopModeDeprecated) {
+                    controller.isInDesktopModeDeprecated = true
+                    controller.notifyTaskbarDesktopModeListenersForEntry(transitionDuration)
+                }
             }
         }
 
+        // TODO: b/402496827 - The multi-desks backend needs to be updated to call this API only
+        //  once, not between desk switches.
         override fun onExitDesktopModeTransitionStarted(transitionDuration: Int) {
+            val controller = controller.get() ?: return
             MAIN_EXECUTOR.execute {
                 Log.d(
                     TAG,
@@ -704,8 +719,12 @@
                         "duration= " +
                         transitionDuration),
                 )
-                controller.get()?.isInDesktopMode = false
-                controller.get()?.notifyTaskbarDesktopModeListenersForExit(transitionDuration)
+                if (enableMultipleDesktops(context)) {
+                    controller.notifyTaskbarDesktopModeListenersForExit(transitionDuration)
+                } else if (controller.isInDesktopModeDeprecated) {
+                    controller.isInDesktopModeDeprecated = false
+                    controller.notifyTaskbarDesktopModeListenersForExit(transitionDuration)
+                }
             }
         }
 
diff --git a/quickstep/src/com/android/launcher3/taskbar/BaseTaskbarContext.java b/quickstep/src/com/android/launcher3/taskbar/BaseTaskbarContext.java
index 09a8670..b82e6ed 100644
--- a/quickstep/src/com/android/launcher3/taskbar/BaseTaskbarContext.java
+++ b/quickstep/src/com/android/launcher3/taskbar/BaseTaskbarContext.java
@@ -23,6 +23,7 @@
 
 import com.android.launcher3.popup.SystemShortcut;
 import com.android.launcher3.util.BaseContext;
+import com.android.launcher3.util.NavigationMode;
 import com.android.launcher3.util.Themes;
 import com.android.quickstep.SystemUiProxy;
 
@@ -33,11 +34,49 @@
 
     protected final LayoutInflater mLayoutInflater;
 
-    public BaseTaskbarContext(Context windowContext) {
+    public BaseTaskbarContext(Context windowContext, boolean isPrimaryDisplay) {
         super(windowContext, Themes.getActivityThemeRes(windowContext));
         mLayoutInflater = LayoutInflater.from(this).cloneInContext(this);
     }
 
+    /**
+     * Returns whether taskbar is transient or persistent. External displays will be persistent.
+     *
+     * @return {@code true} if transient, {@code false} if persistent.
+     */
+    public abstract boolean isTransientTaskbar();
+
+    /**
+     * Returns whether the taskbar is pinned in gesture navigation mode.
+     */
+    public abstract boolean isPinnedTaskbar();
+
+    /**
+     * Returns the current navigation mode. External displays will be in THREE_BUTTONS mode.
+     */
+    public abstract NavigationMode getNavigationMode();
+
+    /**
+     * Returns whether the taskbar is in desktop mode.
+     */
+    public abstract boolean isInDesktopMode();
+
+    /**
+     * Returns whether the taskbar is forced to be pinned when home is visible.
+     */
+    public abstract  boolean showLockedTaskbarOnHome();
+
+    /**
+     * Returns whether desktop taskbar (pinned taskbar that shows desktop tasks) is to be used on
+     * the display because the display is a freeform display.
+     */
+    public abstract  boolean showDesktopTaskbarForFreeformDisplay();
+
+    /**
+     * Returns whether the taskbar is displayed on primary or external display.
+     */
+    public abstract boolean isPrimaryDisplay();
+
     @Override
     public final LayoutInflater getLayoutInflater() {
         return mLayoutInflater;
diff --git a/quickstep/src/com/android/launcher3/taskbar/KeyboardQuickSwitchTaskView.java b/quickstep/src/com/android/launcher3/taskbar/KeyboardQuickSwitchTaskView.java
index 15be03a..c49029d 100644
--- a/quickstep/src/com/android/launcher3/taskbar/KeyboardQuickSwitchTaskView.java
+++ b/quickstep/src/com/android/launcher3/taskbar/KeyboardQuickSwitchTaskView.java
@@ -129,7 +129,9 @@
                         : resources.getDimensionPixelSize(
                                 R.dimen.keyboard_quick_switch_task_view_radius),
                 /* borderWidthPx= */ resources.getDimensionPixelSize(
-                                R.dimen.keyboard_quick_switch_border_width),
+                        R.dimen.keyboard_quick_switch_border_width),
+                /* borderStrokePx= */ resources.getDimensionPixelSize(
+                        R.dimen.keyboard_quick_switch_border_stroke),
                 /* boundsBuilder= */ bounds -> {
                     bounds.set(0, 0, getWidth(), getHeight());
                     return Unit.INSTANCE;
diff --git a/quickstep/src/com/android/launcher3/taskbar/KeyboardQuickSwitchViewController.java b/quickstep/src/com/android/launcher3/taskbar/KeyboardQuickSwitchViewController.java
index 5f7a026..b5f2532 100644
--- a/quickstep/src/com/android/launcher3/taskbar/KeyboardQuickSwitchViewController.java
+++ b/quickstep/src/com/android/launcher3/taskbar/KeyboardQuickSwitchViewController.java
@@ -40,7 +40,6 @@
 import com.android.launcher3.desktop.DesktopAppLaunchTransition;
 import com.android.launcher3.taskbar.overlay.TaskbarOverlayContext;
 import com.android.launcher3.taskbar.overlay.TaskbarOverlayDragLayer;
-import com.android.launcher3.util.DisplayController;
 import com.android.launcher3.views.BaseDragLayer;
 import com.android.quickstep.SystemUiProxy;
 import com.android.quickstep.util.GroupTask;
@@ -106,8 +105,7 @@
             boolean hasDesktopTask,
             boolean wasDesktopTaskFilteredOut,
             boolean wasOpenedFromTaskbar) {
-        final boolean isTransientTaskBar = DisplayController.isTransientTaskbar(
-                mControllers.taskbarActivityContext);
+        final boolean isTransientTaskBar = mControllers.taskbarActivityContext.isTransientTaskbar();
         positionView(wasOpenedFromTaskbar, isTransientTaskBar);
 
         // Keep the taskbar unstashed if the KQS is opened.
diff --git a/quickstep/src/com/android/launcher3/taskbar/LauncherTaskbarUIController.java b/quickstep/src/com/android/launcher3/taskbar/LauncherTaskbarUIController.java
index 62f546b..913035a 100644
--- a/quickstep/src/com/android/launcher3/taskbar/LauncherTaskbarUIController.java
+++ b/quickstep/src/com/android/launcher3/taskbar/LauncherTaskbarUIController.java
@@ -17,12 +17,14 @@
 
 import static android.window.DesktopModeFlags.ENABLE_DESKTOP_WINDOWING_WALLPAPER_ACTIVITY;
 
+import static com.android.launcher3.Flags.syncAppLaunchWithTaskbarStash;
 import static com.android.launcher3.QuickstepTransitionManager.TASKBAR_TO_APP_DURATION;
 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;
+import static com.android.launcher3.taskbar.TaskbarStashController.FLAG_IGNORE_IN_APP;
 
 import android.animation.Animator;
 import android.animation.AnimatorSet;
@@ -221,13 +223,13 @@
         if (!Flags.predictiveBackToHomePolish()) {
             shouldOverrideToFastAnimation |= mLauncher.getPredictiveBackToHomeInProgress();
         }
-        boolean isPinnedTaskbar = DisplayController.isPinnedTaskbar(mLauncher);
+        boolean isPinnedTaskbar =
+                mControllers.taskbarActivityContext.isPinnedTaskbar();
         if (isVisible || isPinnedTaskbar) {
             return getTaskbarToHomeDuration(shouldOverrideToFastAnimation, isPinnedTaskbar);
         } else {
-            return DisplayController.isTransientTaskbar(mLauncher)
-                    ? TRANSIENT_TASKBAR_TRANSITION_DURATION
-                    : TASKBAR_TO_APP_DURATION;
+            return mControllers.taskbarActivityContext.isTransientTaskbar()
+                    ? TRANSIENT_TASKBAR_TRANSITION_DURATION : TASKBAR_TO_APP_DURATION;
         }
     }
 
@@ -302,6 +304,29 @@
         return mTaskbarLauncherStateController.createAnimToLauncher(toState, callbacks, duration);
     }
 
+    /**
+     * Create Taskbar animation to be played alongside the Launcher app launch animation.
+     */
+    public @Nullable Animator createAnimToApp() {
+        if (!syncAppLaunchWithTaskbarStash()) {
+            return null;
+        }
+        TaskbarStashController stashController = mControllers.taskbarStashController;
+        stashController.updateStateForFlag(TaskbarStashController.FLAG_IN_APP, true);
+        return stashController.createApplyStateAnimator(stashController.getStashDuration());
+    }
+
+    /**
+     * Temporarily ignore FLAG_IN_APP for app launches to prevent premature taskbar stashing.
+     * This is needed because taskbar gets a signal to stash before we actually start the
+     * app launch animation.
+     */
+    public void setIgnoreInAppFlagForSync(boolean enabled) {
+        if (syncAppLaunchWithTaskbarStash()) {
+            mControllers.taskbarStashController.updateStateForFlag(FLAG_IGNORE_IN_APP, enabled);
+        }
+    }
+
     public void updateTaskbarLauncherStateGoingHome() {
         mTaskbarLauncherStateController.updateStateForFlag(FLAG_VISIBLE, true);
         mTaskbarLauncherStateController.applyState();
@@ -337,7 +362,7 @@
         }
 
         // Persistent features EDU tooltip.
-        if (!DisplayController.isTransientTaskbar(mLauncher)) {
+        if (!mControllers.taskbarActivityContext.isTransientTaskbar()) {
             mControllers.taskbarEduTooltipController.maybeShowFeaturesEdu();
             return;
         }
@@ -360,7 +385,7 @@
         }
 
         // Persistent features EDU tooltip.
-        if (!DisplayController.isTransientTaskbar(mLauncher)) {
+        if (!mControllers.taskbarActivityContext.isTransientTaskbar()) {
             return !OnboardingPrefs.TASKBAR_EDU_TOOLTIP_STEP.hasReachedMax(mLauncher);
         }
 
diff --git a/quickstep/src/com/android/launcher3/taskbar/NavbarButtonsViewController.java b/quickstep/src/com/android/launcher3/taskbar/NavbarButtonsViewController.java
index ee5b8d1..7d2dc71 100644
--- a/quickstep/src/com/android/launcher3/taskbar/NavbarButtonsViewController.java
+++ b/quickstep/src/com/android/launcher3/taskbar/NavbarButtonsViewController.java
@@ -15,7 +15,6 @@
  */
 package com.android.launcher3.taskbar;
 
-import static android.view.KeyEvent.ACTION_UP;
 import static android.view.View.AccessibilityDelegate;
 import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
 import static android.view.ViewTreeObserver.InternalInsetsInfo.TOUCHABLE_INSETS_REGION;
@@ -42,8 +41,8 @@
 import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_BACK_DISABLED;
 import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_BACK_DISMISS_IME;
 import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_HOME_DISABLED;
-import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_IME_VISIBLE;
 import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_IME_SWITCHER_BUTTON_VISIBLE;
+import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_IME_VISIBLE;
 import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_NAV_BAR_HIDDEN;
 import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_NOTIFICATION_PANEL_EXPANDED;
 import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_OVERVIEW_DISABLED;
@@ -121,6 +120,7 @@
 import java.io.PrintWriter;
 import java.util.ArrayList;
 import java.util.StringJoiner;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.IntPredicate;
 
 /**
@@ -174,6 +174,7 @@
     private static final int NUM_ALPHA_CHANNELS = 3;
 
     private static final long AUTODIM_TIMEOUT_MS = 2250;
+    private static final long PREDICTIVE_BACK_TIMEOUT_MS = 200;
 
     private final ArrayList<StatePropertyHolder> mPropertyHolders = new ArrayList<>();
     private final ArrayList<ImageView> mAllButtons = new ArrayList<>();
@@ -487,8 +488,17 @@
         mPropertyHolders.add(
                 new StatePropertyHolder(mHomeButtonAlpha.get(
                         ALPHA_INDEX_KEYGUARD_OR_DISABLE),
-                        flags -> (flags & FLAG_KEYGUARD_VISIBLE) == 0
-                                && (flags & FLAG_DISABLE_HOME) == 0 && !mContext.isGestureNav()));
+                        flags -> {
+                            /* when the keyguard is visible hide home button. Anytime we are
+                             * occluded we want to show the home button for apps over keyguard.
+                             * however we don't want to show when not occluded/visible.
+                             * (visible false || occluded true) && disable false && not gnav
+                             */
+                            return ((flags & FLAG_KEYGUARD_VISIBLE) == 0
+                                    || (flags & FLAG_KEYGUARD_OCCLUDED) != 0)
+                                    && (flags & FLAG_DISABLE_HOME) == 0
+                                    && !mContext.isGestureNav();
+                        }));
 
         // Recents button
         mRecentsButton = addButton(R.drawable.ic_sysbar_recent, BUTTON_RECENTS,
@@ -870,6 +880,9 @@
         if (predictiveBackThreeButtonNav() && buttonType == BUTTON_BACK) {
             // set up special touch listener for back button to support predictive back
             setBackButtonTouchListener(buttonView, navButtonController);
+            // Set this View clickable, so that NearestTouchFrame.java forwards closeby touches to
+            // this View
+            buttonView.setClickable(true);
         } else {
             buttonView.setOnClickListener(view ->
                     navButtonController.onButtonClick(buttonType, view));
@@ -882,23 +895,36 @@
     private void setBackButtonTouchListener(View buttonView,
             TaskbarNavButtonController navButtonController) {
         final RectF rect = new RectF();
+        final AtomicBoolean hasSentDownEvent = new AtomicBoolean(false);
+        final Runnable longPressTimeout = () -> {
+            navButtonController.sendBackKeyEvent(KeyEvent.ACTION_DOWN, /*cancelled*/ false);
+            hasSentDownEvent.set(true);
+        };
         buttonView.setOnTouchListener((v, event) -> {
             int motionEventAction = event.getAction();
             if (motionEventAction == MotionEvent.ACTION_DOWN) {
+                hasSentDownEvent.set(false);
+                mHandler.postDelayed(longPressTimeout, PREDICTIVE_BACK_TIMEOUT_MS);
                 rect.set(0, 0, v.getWidth(), v.getHeight());
             }
             boolean isCancelled = motionEventAction == MotionEvent.ACTION_CANCEL
                     || (!rect.contains(event.getX(), event.getY())
                     && (motionEventAction == MotionEvent.ACTION_MOVE
                     || motionEventAction == MotionEvent.ACTION_UP));
-            if (motionEventAction != MotionEvent.ACTION_DOWN
-                    && motionEventAction != MotionEvent.ACTION_UP && !isCancelled) {
-                // return early. we don't care about any other cases than DOWN, UP and CANCEL
+            if (motionEventAction != MotionEvent.ACTION_UP && !isCancelled) {
+                // return early. we don't care about any other cases than UP or CANCEL from here on
                 return false;
             }
-            int keyEventAction = motionEventAction == MotionEvent.ACTION_DOWN
-                    ? KeyEvent.ACTION_DOWN : ACTION_UP;
-            navButtonController.sendBackKeyEvent(keyEventAction, isCancelled);
+            mHandler.removeCallbacks(longPressTimeout);
+            if (!hasSentDownEvent.get()) {
+                if (isCancelled) {
+                    // if it is cancelled and ACTION_DOWN has not been sent yet, return early and
+                    // don't send anything to sysui.
+                    return false;
+                }
+                navButtonController.sendBackKeyEvent(KeyEvent.ACTION_DOWN, isCancelled);
+            }
+            navButtonController.sendBackKeyEvent(KeyEvent.ACTION_UP, isCancelled);
             if (motionEventAction == MotionEvent.ACTION_UP && !isCancelled) {
                 buttonView.performClick();
                 buttonView.performHapticFeedback(HapticFeedbackConstants.VIRTUAL_KEY);
diff --git a/quickstep/src/com/android/launcher3/taskbar/StashedHandleViewController.java b/quickstep/src/com/android/launcher3/taskbar/StashedHandleViewController.java
index 2e5bebc..6bd3d85 100644
--- a/quickstep/src/com/android/launcher3/taskbar/StashedHandleViewController.java
+++ b/quickstep/src/com/android/launcher3/taskbar/StashedHandleViewController.java
@@ -36,7 +36,6 @@
 import com.android.launcher3.anim.AnimatedFloat;
 import com.android.launcher3.anim.RevealOutlineAnimation;
 import com.android.launcher3.anim.RoundedRectRevealOutlineProvider;
-import com.android.launcher3.util.DisplayController;
 import com.android.launcher3.util.Executors;
 import com.android.launcher3.util.MultiPropertyFactory;
 import com.android.launcher3.util.MultiValueAlpha;
@@ -217,7 +216,7 @@
                 .getTransientTaskbarIconLayoutBounds();
         float startRadius = mStashedHandleRadius;
 
-        if (DisplayController.isTransientTaskbar(mActivity)) {
+        if (mActivity.isTransientTaskbar()) {
             // Account for the full visual height of the transient taskbar.
             int heightDiff = (mTaskbarSize - visualBounds.height()) / 2;
             visualBounds.top -= heightDiff;
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarActivityContext.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarActivityContext.java
index 6afbebf..66887d0 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarActivityContext.java
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarActivityContext.java
@@ -65,6 +65,7 @@
 import android.content.res.Resources;
 import android.graphics.PixelFormat;
 import android.graphics.Rect;
+import android.graphics.drawable.Drawable;
 import android.hardware.display.DisplayManager;
 import android.os.IRemoteCallback;
 import android.os.Process;
@@ -98,7 +99,9 @@
 import com.android.launcher3.LauncherPrefs;
 import com.android.launcher3.LauncherSettings.Favorites;
 import com.android.launcher3.R;
+import com.android.launcher3.Utilities;
 import com.android.launcher3.allapps.ActivityAllAppsContainerView;
+import com.android.launcher3.anim.AnimatorListeners;
 import com.android.launcher3.anim.AnimatorPlaybackController;
 import com.android.launcher3.apppairs.AppPairIcon;
 import com.android.launcher3.config.FeatureFlags;
@@ -106,6 +109,8 @@
 import com.android.launcher3.desktop.DesktopAppLaunchTransition.AppLaunchType;
 import com.android.launcher3.folder.Folder;
 import com.android.launcher3.folder.FolderIcon;
+import com.android.launcher3.icons.BitmapRenderer;
+import com.android.launcher3.icons.FastBitmapDrawable;
 import com.android.launcher3.logger.LauncherAtom;
 import com.android.launcher3.logging.StatsLogManager;
 import com.android.launcher3.model.data.AppInfo;
@@ -138,7 +143,9 @@
 import com.android.launcher3.taskbar.bubbles.stashing.TransientBubbleStashController;
 import com.android.launcher3.taskbar.customization.TaskbarFeatureEvaluator;
 import com.android.launcher3.taskbar.customization.TaskbarSpecsEvaluator;
+import com.android.launcher3.taskbar.growth.NudgeController;
 import com.android.launcher3.taskbar.navbutton.NearestTouchFrame;
+import com.android.launcher3.taskbar.overlay.TaskbarOverlayContext;
 import com.android.launcher3.taskbar.overlay.TaskbarOverlayController;
 import com.android.launcher3.testing.TestLogging;
 import com.android.launcher3.testing.shared.TestProtocol;
@@ -159,6 +166,7 @@
 import com.android.launcher3.util.TraceHelper;
 import com.android.launcher3.util.VibratorWrapper;
 import com.android.launcher3.views.ActivityContext;
+import com.android.launcher3.views.BaseDragLayer;
 import com.android.quickstep.NavHandle;
 import com.android.quickstep.RecentsModel;
 import com.android.quickstep.SystemUiProxy;
@@ -169,6 +177,7 @@
 import com.android.quickstep.views.DesktopTaskView;
 import com.android.quickstep.views.RecentsView;
 import com.android.quickstep.views.TaskView;
+import com.android.systemui.animation.ViewRootSync;
 import com.android.systemui.shared.recents.model.Task;
 import com.android.systemui.shared.rotation.RotationButtonController;
 import com.android.systemui.shared.statusbar.phone.BarTransitions;
@@ -197,7 +206,7 @@
 
     private static final String WINDOW_TITLE = "Taskbar";
 
-    private static final DesktopModeFlag ENABLE_TASKBAR_BEHIND_SHADE = new DesktopModeFlag(
+    protected static final DesktopModeFlag ENABLE_TASKBAR_BEHIND_SHADE = new DesktopModeFlag(
             Flags::enableTaskbarBehindShade, false);
 
     private final @Nullable Context mNavigationBarPanelContext;
@@ -250,12 +259,16 @@
 
     private TaskbarSpecsEvaluator mTaskbarSpecsEvaluator;
 
+    // Snapshot is used to temporarily draw taskbar behind the shade.
+    private @Nullable View mTaskbarSnapshotView;
+    private @Nullable TaskbarOverlayContext mTaskbarSnapshotOverlay;
+
     public TaskbarActivityContext(Context windowContext,
             @Nullable Context navigationBarPanelContext, DeviceProfile launcherDp,
             TaskbarNavButtonController buttonController,
             ScopedUnfoldTransitionProgressProvider unfoldTransitionProgressProvider,
             boolean isPrimaryDisplay, SystemUiProxy sysUiProxy) {
-        super(windowContext);
+        super(windowContext, isPrimaryDisplay);
         mIsPrimaryDisplay = isPrimaryDisplay;
         mNavigationBarPanelContext = navigationBarPanelContext;
         mSysUiProxy = sysUiProxy;
@@ -307,6 +320,7 @@
         if (BubbleBarController.isBubbleBarEnabled()
                 && deviceBubbleBarEnabled
                 && bubbleBarView != null
+                && isPrimaryDisplay
         ) {
             Optional<BubbleStashedHandleViewController> bubbleHandleController = Optional.empty();
             Optional<BubbleBarSwipeController> bubbleBarSwipeController = Optional.empty();
@@ -380,19 +394,13 @@
                 new TaskbarPinningController(this),
                 bubbleControllersOptional,
                 new TaskbarDesktopModeController(this,
-                        DesktopVisibilityController.INSTANCE.get(this)));
+                        DesktopVisibilityController.INSTANCE.get(this)),
+                new NudgeController(this));
 
         mLauncherPrefs = LauncherPrefs.get(this);
         onViewCreated();
     }
 
-    /**
-     * Returns whether this is a primary display.
-     */
-    public boolean isPrimaryDisplay() {
-        return mIsPrimaryDisplay;
-    }
-
     /** Updates {@link DeviceProfile} instances for any Taskbar windows. */
     public void updateDeviceProfile(DeviceProfile launcherDp) {
         applyDeviceProfile(launcherDp);
@@ -409,9 +417,41 @@
         dispatchDeviceProfileChanged();
     }
 
-    /** Returns whether current taskbar is transient. */
+    @Override
     public boolean isTransientTaskbar() {
-        return DisplayController.isTransientTaskbar(this) && !isPhoneMode();
+        return DisplayController.isTransientTaskbar(this) && mIsPrimaryDisplay && !isPhoneMode();
+    }
+
+    @Override
+    public boolean isPinnedTaskbar() {
+        return DisplayController.isPinnedTaskbar(this);
+    }
+
+    @Override
+    public NavigationMode getNavigationMode() {
+        return isPrimaryDisplay() ? DisplayController.getNavigationMode(this)
+                : NavigationMode.THREE_BUTTONS;
+    }
+
+    @Override
+    public boolean isInDesktopMode() {
+        return mControllers != null
+                && mControllers.taskbarDesktopModeController.isInDesktopMode(getDisplayId());
+    }
+
+    @Override
+    public boolean showLockedTaskbarOnHome() {
+        return DisplayController.showLockedTaskbarOnHome(this);
+    }
+
+    @Override
+    public boolean showDesktopTaskbarForFreeformDisplay() {
+        return DisplayController.showDesktopTaskbarForFreeformDisplay(this);
+    }
+
+    @Override
+    public boolean isPrimaryDisplay() {
+        return mIsPrimaryDisplay;
     }
 
     /**
@@ -432,7 +472,7 @@
         mDeviceProfile = originDeviceProfile.toBuilder(this)
                 .withDimensionsOverride(overrideProvider).build();
 
-        if (DisplayController.isTransientTaskbar(this)) {
+        if (isTransientTaskbar()) {
             mTransientTaskbarDeviceProfile = mDeviceProfile;
             mPersistentTaskbarDeviceProfile = mDeviceProfile
                     .toBuilder(this)
@@ -447,10 +487,7 @@
                     .setIsTransientTaskbar(true)
                     .build();
         }
-        mNavMode = (DesktopExperienceFlags.ENABLE_TASKBAR_CONNECTED_DISPLAYS.isTrue()
-                && !mIsPrimaryDisplay) ? NavigationMode.THREE_BUTTONS
-                : DisplayController.getNavigationMode(this);
-
+        mNavMode = getNavigationMode();
     }
 
     /** Called when the visibility of the bubble bar changed. */
@@ -659,10 +696,8 @@
      */
     public WindowManager.LayoutParams createDefaultWindowLayoutParams(int type, String title) {
         int windowFlags = WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
-                | WindowManager.LayoutParams.FLAG_SLIPPERY
-                | WindowManager.LayoutParams.FLAG_SPLIT_TOUCH;
-        boolean watchOutside = DisplayController.isTransientTaskbar(this)
-                || isThreeButtonNav();
+                | WindowManager.LayoutParams.FLAG_SLIPPERY;
+        boolean watchOutside = isTransientTaskbar() || isThreeButtonNav();
         if (watchOutside && !isRunningInTestHarness()) {
             windowFlags |= WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL
                     | WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH;
@@ -1002,6 +1037,8 @@
             mWindowManager.removeViewImmediate(mDragLayer);
             mAddedWindow = false;
         }
+        mTaskbarSnapshotView = null;
+        mTaskbarSnapshotOverlay = null;
     }
 
     public boolean isDestroyed() {
@@ -1073,6 +1110,80 @@
         if (skipAnim) {
             anim.end();
         }
+
+        updateTaskbarSnapshot(anim, isExpanded);
+    }
+
+    private void updateTaskbarSnapshot(AnimatorSet anim, boolean isExpanded) {
+        if (!ENABLE_TASKBAR_BEHIND_SHADE.isTrue()) {
+            return;
+        }
+        if (mTaskbarSnapshotView == null) {
+            mTaskbarSnapshotView = new View(this);
+        }
+        if (isExpanded) {
+            if (!mTaskbarSnapshotView.isAttachedToWindow()
+                    && mDragLayer.isAttachedToWindow()
+                    && mDragLayer.isLaidOut()
+                    && mTaskbarSnapshotView.getParent() == null) {
+                NearestTouchFrame navButtonsView = mDragLayer.findViewById(R.id.navbuttons_view);
+                int oldNavButtonsVisibility = navButtonsView.getVisibility();
+                navButtonsView.setVisibility(View.INVISIBLE);
+
+                Drawable drawable = new FastBitmapDrawable(BitmapRenderer.createHardwareBitmap(
+                        mDragLayer.getWidth(),
+                        mDragLayer.getHeight(),
+                        mDragLayer::draw));
+
+                navButtonsView.setVisibility(oldNavButtonsVisibility);
+                mTaskbarSnapshotView.setBackground(drawable);
+                mTaskbarSnapshotView.setAlpha(0f);
+
+                mTaskbarSnapshotView.addOnAttachStateChangeListener(
+                        new View.OnAttachStateChangeListener() {
+                            @Override
+                            public void onViewAttachedToWindow(@NonNull View v) {
+                                mTaskbarSnapshotView.removeOnAttachStateChangeListener(this);
+                                anim.end();
+                                mTaskbarSnapshotView.setAlpha(1f);
+                                if (!Utilities.isRunningInTestHarness()) {
+                                    ViewRootSync.synchronizeNextDraw(mDragLayer,
+                                            mTaskbarSnapshotView,
+                                            () -> {});
+                                }
+                            }
+
+                            @Override
+                            public void onViewDetachedFromWindow(@NonNull View v) {}
+                        });
+                BaseDragLayer.LayoutParams layoutParams = new BaseDragLayer.LayoutParams(
+                        mDragLayer.getWidth(), mDragLayer.getHeight());
+                layoutParams.gravity = mWindowLayoutParams.gravity;
+                layoutParams.ignoreInsets = true;
+                mTaskbarSnapshotOverlay = mControllers.taskbarOverlayController.requestWindow();
+                mTaskbarSnapshotOverlay.getDragLayer().addView(mTaskbarSnapshotView, layoutParams);
+            }
+        } else {
+            Runnable removeSnapshotView = () -> {
+                if (mTaskbarSnapshotOverlay != null) {
+                    mTaskbarSnapshotOverlay.getDragLayer().removeView(mTaskbarSnapshotView);
+                    mTaskbarSnapshotView = null;
+                    mTaskbarSnapshotOverlay = null;
+                }
+            };
+            if (mTaskbarSnapshotView.isAttachedToWindow()) {
+                mTaskbarSnapshotView.setAlpha(0f);
+                anim.end();
+                if (Utilities.isRunningInTestHarness()) {
+                    removeSnapshotView.run();
+                } else {
+                    ViewRootSync.synchronizeNextDraw(mDragLayer, mTaskbarSnapshotView,
+                            removeSnapshotView);
+                }
+            } else {
+                removeSnapshotView.run();
+            }
+        }
     }
 
     public void onRotationProposal(int rotation, boolean isValid) {
@@ -1223,8 +1334,8 @@
                 bubbleControllers.bubbleBarViewController.getBubbleBarWithFlyoutMaximumHeight()
         ).orElse(0);
         int taskbarWindowSize;
-        boolean shouldTreatAsTransient = DisplayController.isTransientTaskbar(this)
-                || (enableTaskbarPinning() && !isThreeButtonNav());
+        boolean shouldTreatAsTransient =
+                isTransientTaskbar() || (enableTaskbarPinning() && !isThreeButtonNav());
 
         int extraHeightForTaskbarTooltips = enableCursorHoverStates()
                 ? resources.getDimensionPixelSize(R.dimen.arrow_toast_arrow_height)
@@ -1297,7 +1408,7 @@
      * Applies forcibly show flag to taskbar window iff transient taskbar is unstashed.
      */
     public void applyForciblyShownFlagWhileTransientTaskbarUnstashed(boolean shouldForceShow) {
-        if (!DisplayController.isTransientTaskbar(this) || isPhoneMode()) {
+        if (!isTransientTaskbar() || isPhoneMode()) {
             return;
         }
         if (shouldForceShow) {
@@ -1344,11 +1455,6 @@
         mControllers.uiController.startSplitSelection(splitSelectSource);
     }
 
-    boolean areDesktopTasksVisible() {
-        return mControllers != null
-                && mControllers.taskbarDesktopModeController.isInDesktopMode(getDisplayId());
-    }
-
     protected void onTaskbarIconClicked(View view) {
         TaskbarUIController taskbarUIController = mControllers.uiController;
         RecentsView recents = taskbarUIController.getRecentsView();
@@ -1360,23 +1466,23 @@
         // TODO: b/316004172, b/343289567: Handle `DesktopTask` and `SplitTask`.
         if (tag instanceof SingleTask singleTask) {
             RemoteTransition remoteTransition =
-                    (areDesktopTasksVisible() && canUnminimizeDesktopTask(
+                    (isInDesktopMode() && canUnminimizeDesktopTask(
                             singleTask.getTask().key.id))
                             ? createDesktopAppLaunchRemoteTransition(AppLaunchType.UNMINIMIZE,
                             Cuj.CUJ_DESKTOP_MODE_APP_LAUNCH_FROM_ICON)
                             : null;
-            if (areDesktopTasksVisible() && mControllers.uiController.isInOverviewUi()) {
+            if (isInDesktopMode() && mControllers.uiController.isInOverviewUi()) {
                 RunnableList runnableList = recents.launchRunningDesktopTaskView();
                 // Wrapping it in runnable so we post after DW is ready for the app
                 // launch.
                 if (runnableList != null) {
                     runnableList.add(() -> UI_HELPER_EXECUTOR.execute(
                             () -> handleGroupTaskLaunch(singleTask, remoteTransition,
-                                    areDesktopTasksVisible(),
+                                    isInDesktopMode(),
                                     DesktopTaskToFrontReason.TASKBAR_TAP)));
                 }
             } else {
-                handleGroupTaskLaunch(singleTask, remoteTransition, areDesktopTasksVisible(),
+                handleGroupTaskLaunch(singleTask, remoteTransition, isInDesktopMode(),
                         DesktopTaskToFrontReason.TASKBAR_TAP);
             }
             mControllers.taskbarStashController.updateAndAnimateTransientTaskbar(true);
@@ -1402,7 +1508,7 @@
                     : null;
 
 
-            if (areDesktopTasksVisible() && mControllers.uiController.isInOverviewUi()) {
+            if (isInDesktopMode() && mControllers.uiController.isInOverviewUi()) {
                 RunnableList runnableList = recents.launchRunningDesktopTaskView();
                 if (runnableList != null) {
                     runnableList.add(() ->
@@ -1676,7 +1782,7 @@
                                                 .launchAppPair((AppPairIcon) launchingIconView,
                                                         -1 /*cuj*/)));
                     } else {
-                        if (areDesktopTasksVisible()
+                        if (isInDesktopMode()
                                 && mControllers.uiController.isInOverviewUi()) {
                             RunnableList runnableList = recents.launchRunningDesktopTaskView();
                             // Wrapping it in runnable so we post after DW is ready for the app
@@ -1722,7 +1828,7 @@
                     return;
                 }
             }
-            if (areDesktopTasksVisible()
+            if (isInDesktopMode()
                     && DesktopModeFlags.ENABLE_DESKTOP_APP_LAUNCH_TRANSITIONS_BUGFIX.isTrue()) {
                 launchDesktopApp(intent, info, displayId);
             } else {
@@ -1887,7 +1993,7 @@
      */
     @VisibleForTesting
     public void unstashTaskbarIfStashed() {
-        if (DisplayController.isTransientTaskbar(this)) {
+        if (isTransientTaskbar()) {
             mControllers.taskbarStashController.updateAndAnimateTransientTaskbar(false);
         }
     }
@@ -1950,6 +2056,8 @@
                 // Override the alpha updates in the icon alignment animation.
                 allAppsButton.setAlpha(0);
             });
+            alphaOverride.addListener(AnimatorListeners.forSuccessCallback(
+                    () -> allAppsButton.setAlpha(1f)));
             fullAnimation.play(alphaOverride);
         }
 
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarBackgroundRenderer.kt b/quickstep/src/com/android/launcher3/taskbar/TaskbarBackgroundRenderer.kt
index 89cc991..5e02d81 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarBackgroundRenderer.kt
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarBackgroundRenderer.kt
@@ -30,7 +30,6 @@
 import com.android.launcher3.icons.GraphicsUtils.setColorAlphaBound
 import com.android.launcher3.taskbar.TaskbarPinningController.Companion.PINNING_PERSISTENT
 import com.android.launcher3.taskbar.TaskbarPinningController.Companion.PINNING_TRANSIENT
-import com.android.launcher3.util.DisplayController
 import kotlin.math.min
 
 /** Helps draw the taskbar background, made up of a rectangle plus two inverted rounded corners. */
@@ -43,7 +42,7 @@
     private val maxPersistentTaskbarHeight =
         context.persistentTaskbarDeviceProfile.taskbarHeight.toFloat()
     var backgroundProgress =
-        if (DisplayController.isTransientTaskbar(context)) {
+        if (context.isTransientTaskbar) {
             PINNING_TRANSIENT
         } else {
             PINNING_PERSISTENT
@@ -102,7 +101,7 @@
 
         fullCornerRadius = context.cornerRadius.toFloat()
         cornerRadius = fullCornerRadius
-        if (!context.areDesktopTasksVisible()) {
+        if (!context.isInDesktopMode()) {
             setCornerRoundness(MAX_ROUNDNESS)
         }
     }
@@ -124,7 +123,7 @@
      * @param cornerRoundness 0 has no round corner, 1 has complete round corner.
      */
     fun setCornerRoundness(cornerRoundness: Float) {
-        if (DisplayController.isTransientTaskbar(context) && !transientBackgroundBounds.isEmpty) {
+        if (context.isTransientTaskbar && !transientBackgroundBounds.isEmpty) {
             return
         }
 
@@ -146,7 +145,7 @@
     /** Draws the background with the given paint and height, on the provided canvas. */
     fun draw(canvas: Canvas) {
         if (isInSetup) return
-        val isTransientTaskbar = DisplayController.isTransientTaskbar(context)
+        val isTransientTaskbar = context.isTransientTaskbar
         canvas.save()
         if (!isTransientTaskbar || transientBackgroundBounds.isEmpty || isAnimatingPinning) {
             drawPersistentBackground(canvas)
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarControllers.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarControllers.java
index 58606de..9e15a60 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarControllers.java
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarControllers.java
@@ -25,6 +25,7 @@
 import com.android.launcher3.anim.AnimatedFloat;
 import com.android.launcher3.taskbar.allapps.TaskbarAllAppsController;
 import com.android.launcher3.taskbar.bubbles.BubbleControllers;
+import com.android.launcher3.taskbar.growth.NudgeController;
 import com.android.launcher3.taskbar.overlay.TaskbarOverlayController;
 import com.android.systemui.shared.rotation.RotationButtonController;
 import com.android.wm.shell.shared.bubbles.BubbleBarLocation;
@@ -67,6 +68,7 @@
     public final TaskbarPinningController taskbarPinningController;
     public final Optional<BubbleControllers> bubbleControllers;
     public final TaskbarDesktopModeController taskbarDesktopModeController;
+    public final NudgeController nudgeController;
 
     @Nullable private LoggableTaskbarController[] mControllersToLog = null;
     @Nullable private BackgroundRendererController[] mBackgroundRendererControllers = null;
@@ -115,7 +117,8 @@
             KeyboardQuickSwitchController keyboardQuickSwitchController,
             TaskbarPinningController taskbarPinningController,
             Optional<BubbleControllers> bubbleControllers,
-            TaskbarDesktopModeController taskbarDesktopModeController) {
+            TaskbarDesktopModeController taskbarDesktopModeController,
+            NudgeController nudgeController) {
         this.taskbarActivityContext = taskbarActivityContext;
         this.taskbarDragController = taskbarDragController;
         this.navButtonController = navButtonController;
@@ -143,6 +146,7 @@
         this.taskbarPinningController = taskbarPinningController;
         this.bubbleControllers = bubbleControllers;
         this.taskbarDesktopModeController = taskbarDesktopModeController;
+        this.nudgeController = nudgeController;
     }
 
     /**
@@ -179,6 +183,7 @@
         keyboardQuickSwitchController.init(this);
         taskbarPinningController.init(this, mSharedState);
         taskbarDesktopModeController.init(this, mSharedState);
+        nudgeController.init(this);
 
         mControllersToLog = new LoggableTaskbarController[] {
                 taskbarDragController, navButtonController, navbarButtonsViewController,
@@ -189,6 +194,7 @@
                 voiceInteractionWindowController, taskbarRecentAppsController,
                 taskbarTranslationController, taskbarEduTooltipController,
                 keyboardQuickSwitchController, taskbarPinningController,
+                nudgeController
         };
         mBackgroundRendererControllers = new BackgroundRendererController[] {
                 taskbarDragLayerController, taskbarScrimViewController,
@@ -260,6 +266,7 @@
         mAreAllControllersInitialized = false;
         mSharedState = null;
 
+        taskbarDragController.onDestroy();
         navbarButtonsViewController.onDestroy();
         uiController.onDestroy();
         rotationButtonController.onDestroy();
@@ -280,7 +287,6 @@
         taskbarStashController.onDestroy();
         bubbleControllers.ifPresent(controllers -> controllers.onDestroy());
         taskbarDesktopModeController.onDestroy();
-
         mControllersToLog = null;
         mBackgroundRendererControllers = null;
     }
@@ -344,7 +350,7 @@
         return taskbarActivityContext;
     }
 
-    protected interface LoggableTaskbarController {
+    public interface LoggableTaskbarController {
         void dumpLogs(String prefix, PrintWriter pw);
     }
 
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarDesktopModeController.kt b/quickstep/src/com/android/launcher3/taskbar/TaskbarDesktopModeController.kt
index ca8e4ca..e96e67d 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarDesktopModeController.kt
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarDesktopModeController.kt
@@ -20,7 +20,6 @@
 import com.android.launcher3.statehandlers.DesktopVisibilityController
 import com.android.launcher3.statehandlers.DesktopVisibilityController.TaskbarDesktopModeListener
 import com.android.launcher3.taskbar.TaskbarBackgroundRenderer.Companion.MAX_ROUNDNESS
-import com.android.launcher3.util.DisplayController
 
 /** Handles Taskbar in Desktop Windowing mode. */
 class TaskbarDesktopModeController(
@@ -30,9 +29,6 @@
     private lateinit var taskbarControllers: TaskbarControllers
     private lateinit var taskbarSharedState: TaskbarSharedState
 
-    val isInDesktopMode: Boolean
-        get() = desktopVisibilityController.isInDesktopMode
-
     fun init(controllers: TaskbarControllers, sharedState: TaskbarSharedState) {
         taskbarControllers = controllers
         taskbarSharedState = sharedState
@@ -52,9 +48,10 @@
     }
 
     fun shouldShowDesktopTasksInTaskbar(): Boolean {
+        val activityContext = taskbarControllers.taskbarActivityContext
         return isInDesktopMode(context.displayId) ||
-            DisplayController.showDesktopTaskbarForFreeformDisplay(context) ||
-            (DisplayController.showLockedTaskbarOnHome(context) &&
+            activityContext.showDesktopTaskbarForFreeformDisplay() ||
+            (activityContext.showLockedTaskbarOnHome() &&
                 taskbarControllers.taskbarStashController.isOnHome)
     }
 
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarDividerPopupView.kt b/quickstep/src/com/android/launcher3/taskbar/TaskbarDividerPopupView.kt
index 3f6ebe2..b663444 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarDividerPopupView.kt
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarDividerPopupView.kt
@@ -35,7 +35,6 @@
 import com.android.launcher3.R
 import com.android.launcher3.popup.ArrowPopup
 import com.android.launcher3.popup.RoundedArrowDrawable
-import com.android.launcher3.util.DisplayController
 import com.android.launcher3.util.Themes
 import com.android.launcher3.views.ActivityContext
 import kotlin.math.max
@@ -70,6 +69,8 @@
 
     private lateinit var dividerView: View
     private var horizontalPosition = 0.0f
+    private val taskbarActivityContext: TaskbarActivityContext =
+        ActivityContext.lookupContext(context)
 
     private val popupCornerRadius = Themes.getDialogCornerRadius(context)
     private val arrowWidth = resources.getDimension(R.dimen.popup_arrow_width)
@@ -78,7 +79,8 @@
     private val minPaddingFromScreenEdge =
         resources.getDimension(R.dimen.taskbar_pinning_popup_menu_min_padding_from_screen_edge)
 
-    private var alwaysShowTaskbarOn = !DisplayController.isTransientTaskbar(context)
+    // TODO: add test for isTransientTaskbar & long presses divider and ensures the popup shows up.
+    private var alwaysShowTaskbarOn = !taskbarActivityContext.isTransientTaskbar
     private var didPreferenceChange = false
     private var verticalOffsetForPopupView =
         resources.getDimensionPixelSize(R.dimen.taskbar_pinning_popup_menu_vertical_margin)
@@ -113,7 +115,7 @@
         }
         alwaysShowTaskbarSwitch.setOnClickListener { view -> (view.parent as View).performClick() }
 
-        if (ActivityContext.lookupContext<TaskbarActivityContext>(context).isGestureNav) {
+        if (taskbarActivityContext.isGestureNav) {
             taskbarSwitchOption.setOnClickListener {
                 alwaysShowTaskbarSwitch.isChecked = !alwaysShowTaskbarOn
                 onClickAlwaysShowTaskbarSwitchOption()
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarDragController.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarDragController.java
index 1b516be..142f458 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarDragController.java
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarDragController.java
@@ -80,7 +80,6 @@
 import com.android.launcher3.taskbar.bubbles.BubbleBarViewController;
 import com.android.launcher3.testing.TestLogging;
 import com.android.launcher3.testing.shared.TestProtocol;
-import com.android.launcher3.util.DisplayController;
 import com.android.launcher3.util.IntSet;
 import com.android.launcher3.util.ItemInfoMatcher;
 import com.android.launcher3.views.BubbleTextHolder;
@@ -132,6 +131,14 @@
 
     public void init(TaskbarControllers controllers) {
         mControllers = controllers;
+        mControllers.bubbleControllers.ifPresent(
+                c -> c.bubbleBarViewController.addBubbleBarDropTargets(this));
+    }
+
+    /** Called when the controller is destroyed. */
+    public void onDestroy() {
+        mControllers.bubbleControllers.ifPresent(
+                c -> c.bubbleBarViewController.removeBubbleBarDropTargets(this));
     }
 
     public void setDisallowGlobalDrag(boolean disallowGlobalDrag) {
@@ -463,7 +470,7 @@
             com.android.launcher3.logging.InstanceId launcherInstanceId = instanceIds.second;
 
             intent.putExtra(ClipDescription.EXTRA_LOGGING_INSTANCE_ID, internalInstanceId);
-            if (DisplayController.isTransientTaskbar(mActivity)) {
+            if (mActivity.isTransientTaskbar()) {
                 // Tell WM Shell to ignore drag events in the provided transient taskbar region.
                 TaskbarDragLayer dragLayer = mControllers.taskbarActivityContext.getDragLayer();
                 int[] locationOnScreen = dragLayer.getLocationOnScreen();
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarDragLayerController.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarDragLayerController.java
index 55ecc37..1e193f6 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarDragLayerController.java
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarDragLayerController.java
@@ -34,7 +34,6 @@
 import com.android.launcher3.anim.AnimatedFloat;
 import com.android.launcher3.anim.AnimatorListeners;
 import com.android.launcher3.util.DimensionUtils;
-import com.android.launcher3.util.DisplayController;
 import com.android.launcher3.util.MultiPropertyFactory.MultiProperty;
 import com.android.launcher3.util.TouchController;
 
@@ -108,19 +107,18 @@
 
         if (startAnimation != null) {
             // set taskbar background render animation boolean
-            if (DisplayController.isTransientTaskbar(mActivity)) {
+            if (mActivity.isTransientTaskbar()) {
                 mTaskbarDragLayer.setIsAnimatingTransientTaskbarBackground(true);
             } else {
                 mTaskbarDragLayer.setIsAnimatingPersistentTaskbarBackground(true);
             }
 
-            float desiredValue = DisplayController.isTransientTaskbar(mActivity)
+            float desiredValue = mActivity.isTransientTaskbar()
                     ? PINNING_TRANSIENT
                     : PINNING_PERSISTENT;
 
-            float nonDesiredvalue = !DisplayController.isTransientTaskbar(mActivity)
-                    ? PINNING_TRANSIENT
-                    : PINNING_PERSISTENT;
+            float nonDesiredvalue =
+                    !mActivity.isTransientTaskbar() ? PINNING_TRANSIENT : PINNING_PERSISTENT;
 
             ObjectAnimator objectAnimator = mTaskbarBackgroundProgress.animateToValue(
                     nonDesiredvalue, desiredValue);
@@ -133,9 +131,8 @@
             }));
 
         } else {
-            mTaskbarBackgroundProgress.updateValue(DisplayController.isTransientTaskbar(mActivity)
-                    ? PINNING_TRANSIENT
-                    : PINNING_PERSISTENT);
+            mTaskbarBackgroundProgress.updateValue(
+                    mActivity.isTransientTaskbar() ? PINNING_TRANSIENT : PINNING_PERSISTENT);
         }
 
         mBgTaskbar.value = 1;
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarEduTooltipController.kt b/quickstep/src/com/android/launcher3/taskbar/TaskbarEduTooltipController.kt
index d624413..038e374 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarEduTooltipController.kt
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarEduTooltipController.kt
@@ -44,7 +44,6 @@
 import com.android.launcher3.config.FeatureFlags.enableTaskbarPinning
 import com.android.launcher3.taskbar.TaskbarAutohideSuspendController.FLAG_AUTOHIDE_SUSPEND_EDU_OPEN
 import com.android.launcher3.taskbar.TaskbarControllers.LoggableTaskbarController
-import com.android.launcher3.util.DisplayController
 import com.android.launcher3.util.OnboardingPrefs.TASKBAR_EDU_TOOLTIP_STEP
 import com.android.launcher3.util.OnboardingPrefs.TASKBAR_SEARCH_EDU_SEEN
 import com.android.launcher3.util.ResourceBasedOverride
@@ -155,7 +154,7 @@
     fun maybeShowSwipeEdu() {
         if (
             !isTooltipEnabled ||
-                !DisplayController.isTransientTaskbar(activityContext) ||
+                !activityContext.isTransientTaskbar ||
                 tooltipStep > TOOLTIP_STEP_SWIPE
         ) {
             return
@@ -200,7 +199,7 @@
             suggestionsAnim.supportLightTheme()
             pinningAnim.supportLightTheme()
             handleEduAnimations(listOf(splitscreenAnim, suggestionsAnim, pinningAnim))
-            if (DisplayController.isTransientTaskbar(activityContext)) {
+            if (activityContext.isTransientTaskbar) {
                 splitscreenAnim.setAnimation(R.raw.taskbar_edu_splitscreen_transient)
                 suggestionsAnim.setAnimation(R.raw.taskbar_edu_suggestions_transient)
                 pinningEdu.visibility = if (enableTaskbarPinning()) VISIBLE else GONE
@@ -230,7 +229,7 @@
             // Set up layout parameters.
             content.updateLayoutParams { width = MATCH_PARENT }
             updateLayoutParams<MarginLayoutParams> {
-                if (DisplayController.isTransientTaskbar(activityContext)) {
+                if (activityContext.isTransientTaskbar) {
                     width =
                         resources.getDimensionPixelSize(
                             if (enableTaskbarPinning())
@@ -263,7 +262,7 @@
         // for the original 2 edu steps) as a proxy to needing to show the separate pinning edu
         if (
             !enableTaskbarPinning() ||
-                !DisplayController.isTransientTaskbar(activityContext) ||
+                !activityContext.isTransientTaskbar ||
                 !isTooltipEnabled ||
                 tooltipStep > TOOLTIP_STEP_PINNING ||
                 tooltipStep < TOOLTIP_STEP_FEATURES
@@ -289,7 +288,7 @@
             pinningAnim.supportLightTheme()
             handleEduAnimations(listOf(pinningAnim))
             updateLayoutParams<BaseDragLayer.LayoutParams> {
-                if (DisplayController.isTransientTaskbar(activityContext)) {
+                if (activityContext.isTransientTaskbar) {
                     bottomMargin += activityContext.deviceProfile.taskbarHeight
                 }
                 // Unlike other tooltips, we want to align with taskbar divider rather than center.
@@ -319,7 +318,7 @@
     fun maybeShowSearchEdu() {
         if (
             !enableTaskbarPinning() ||
-                !DisplayController.isPinnedTaskbar(activityContext) ||
+                !activityContext.isPinnedTaskbar ||
                 !isTooltipEnabled ||
                 !shouldShowSearchEdu ||
                 userHasSeenSearchEdu ||
@@ -344,7 +343,7 @@
 
             showDisclosureText(eduSubtitle)
             updateLayoutParams<BaseDragLayer.LayoutParams> {
-                if (DisplayController.isTransientTaskbar(activityContext)) {
+                if (activityContext.isTransientTaskbar) {
                     bottomMargin += activityContext.deviceProfile.taskbarHeight
                 }
                 // Unlike other tooltips, we want to align with the all apps button rather than
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarInsetsController.kt b/quickstep/src/com/android/launcher3/taskbar/TaskbarInsetsController.kt
index a8ce10f..f342fa5 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarInsetsController.kt
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarInsetsController.kt
@@ -51,7 +51,6 @@
 import com.android.launcher3.config.FeatureFlags.enableTaskbarNoRecreate
 import com.android.launcher3.taskbar.TaskbarControllers.LoggableTaskbarController
 import com.android.launcher3.testing.shared.ResourceUtils
-import com.android.launcher3.util.DisplayController
 import com.android.launcher3.util.Executors
 import java.io.PrintWriter
 import kotlin.jvm.optionals.getOrNull
@@ -150,7 +149,7 @@
         if (
             taskbarStashController.isInApp ||
                 controllers.uiController.isInOverviewUi ||
-                DisplayController.showLockedTaskbarOnHome(context)
+                context.showLockedTaskbarOnHome()
         ) {
             // only add the taskbar touch region if not on home
             val bottom = windowLayoutParams.height
@@ -235,8 +234,7 @@
                         context.resources,
                     )
                 val isPinnedTaskbar =
-                    context.deviceProfile.isTaskbarPresent &&
-                        !context.deviceProfile.isTransientTaskbar
+                    context.deviceProfile.isTaskbarPresent && !context.isTransientTaskbar
                 val mandatoryGestureHeight = if (isPinnedTaskbar) contentHeight else gestureHeight
                 provider.insetsSize =
                     getInsetsForGravityWithCutout(mandatoryGestureHeight, gravity, endRotation)
@@ -388,10 +386,7 @@
                 bubbleBarVisible
         ) {
             // Taskbar has some touchable elements, take over the full taskbar area
-            if (
-                controllers.uiController.isInOverviewUi &&
-                    DisplayController.isTransientTaskbar(context)
-            ) {
+            if (controllers.uiController.isInOverviewUi && context.isTransientTaskbar) {
                 val region =
                     controllers.taskbarActivityContext.dragLayer.lastDrawnTransientRect.toRegion()
                 val bubbleBarBounds =
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarLauncherStateController.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarLauncherStateController.java
index b510e7e..98415d1 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarLauncherStateController.java
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarLauncherStateController.java
@@ -40,7 +40,6 @@
 import android.animation.AnimatorListenerAdapter;
 import android.animation.AnimatorSet;
 import android.animation.ObjectAnimator;
-import android.content.Context;
 import android.os.SystemClock;
 import android.util.Log;
 import android.view.animation.Interpolator;
@@ -61,7 +60,6 @@
 import com.android.launcher3.statemanager.StateManager;
 import com.android.launcher3.taskbar.bubbles.stashing.BubbleStashController.BubbleLauncherState;
 import com.android.launcher3.uioverrides.QuickstepLauncher;
-import com.android.launcher3.util.DisplayController;
 import com.android.launcher3.util.MultiPropertyFactory.MultiProperty;
 import com.android.quickstep.RecentsAnimationCallbacks;
 import com.android.quickstep.RecentsAnimationController;
@@ -225,11 +223,9 @@
                     updateStateForFlag(FLAG_LAUNCHER_IN_STATE_TRANSITION, true);
                     if (!mShouldDelayLauncherStateAnim) {
                         if (toState == LauncherState.NORMAL) {
+                            TaskbarActivityContext activity = mControllers.taskbarActivityContext;
                             boolean isPinnedTaskbarAndNotInDesktopMode =
-                                    DisplayController.isPinnedTaskbar(
-                                            mControllers.taskbarActivityContext)
-                                            && !DisplayController.isInDesktopMode(
-                                            mControllers.taskbarActivityContext);
+                                    !activity.isInDesktopMode() && activity.isPinnedTaskbar();
                             applyState(QuickstepTransitionManager.getTaskbarToHomeDuration(
                                     isPinnedTaskbarAndNotInDesktopMode));
                         } else {
@@ -475,8 +471,8 @@
         final boolean isIconAlignedWithHotseat = isIconAlignedWithHotseat();
         final float toAlignment = isIconAlignedWithHotseat ? 1 : 0;
         boolean handleOpenFloatingViews = false;
-        boolean isPinnedTaskbar = DisplayController.isPinnedTaskbar(
-                mControllers.taskbarActivityContext);
+        boolean isPinnedTaskbar =
+                mControllers.taskbarActivityContext.isPinnedTaskbar();
         if (DEBUG) {
             Log.d(TAG, "onStateChangeApplied - isInLauncher: " + isInLauncher
                     + ", mLauncherState: " + mLauncherState
@@ -590,7 +586,8 @@
         float backgroundAlpha = isInLauncher && isTaskbarAlignedWithHotseat() ? 0 : 1;
         AnimatedFloat taskbarBgOffset =
                 mControllers.taskbarDragLayerController.getTaskbarBackgroundOffset();
-        boolean showTaskbar = shouldShowTaskbar(mLauncher, isInLauncher, isInOverview);
+        boolean showTaskbar = shouldShowTaskbar(mControllers.taskbarActivityContext, isInLauncher,
+                isInOverview);
         float taskbarBgOffsetEnd = showTaskbar ? 0f : 1f;
         float taskbarBgOffsetStart = showTaskbar ? 1f : 0f;
 
@@ -727,13 +724,13 @@
         return animatorSet;
     }
 
-    private static boolean shouldShowTaskbar(Context context, boolean isInLauncher,
-            boolean isInOverview) {
-        if (DisplayController.showDesktopTaskbarForFreeformDisplay(context)) {
+    private static boolean shouldShowTaskbar(TaskbarActivityContext activityContext,
+            boolean isInLauncher, boolean isInOverview) {
+        if (activityContext.showDesktopTaskbarForFreeformDisplay()) {
             return true;
         }
 
-        if (DisplayController.showLockedTaskbarOnHome(context) && isInLauncher) {
+        if (activityContext.showLockedTaskbarOnHome() && isInLauncher) {
             return true;
         }
         return !isInLauncher || isInOverview;
@@ -788,11 +785,11 @@
      * This refers to the intended state - a transition to this state might be in progress.
      */
     public boolean isTaskbarAlignedWithHotseat() {
-        if (DisplayController.showDesktopTaskbarForFreeformDisplay(mLauncher)) {
+        if (mControllers.taskbarActivityContext.showDesktopTaskbarForFreeformDisplay()) {
             return false;
         }
 
-        if (DisplayController.showLockedTaskbarOnHome(mLauncher) && isInLauncher()) {
+        if (mControllers.taskbarActivityContext.showLockedTaskbarOnHome() && isInLauncher()) {
             return false;
         }
 
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarManager.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarManager.java
index bee0997..1521715 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarManager.java
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarManager.java
@@ -17,6 +17,8 @@
 
 import static android.content.Context.RECEIVER_EXPORTED;
 import static android.content.Context.RECEIVER_NOT_EXPORTED;
+import static android.content.pm.PackageManager.FEATURE_PC;
+import static android.content.pm.PackageManager.FEATURE_FREEFORM_WINDOW_MANAGEMENT;
 import static android.view.WindowManager.LayoutParams.TYPE_NAVIGATION_BAR;
 import static android.view.WindowManager.LayoutParams.TYPE_NAVIGATION_BAR_PANEL;
 
@@ -26,6 +28,7 @@
 import static com.android.launcher3.config.FeatureFlags.ENABLE_TASKBAR_NAVBAR_UNIFICATION;
 import static com.android.launcher3.config.FeatureFlags.enableTaskbarNoRecreate;
 import static com.android.launcher3.taskbar.growth.GrowthConstants.BROADCAST_SHOW_NUDGE;
+import static com.android.launcher3.taskbar.growth.GrowthConstants.GROWTH_NUDGE_PERMISSION;
 import static com.android.launcher3.util.DisplayController.CHANGE_DENSITY;
 import static com.android.launcher3.util.DisplayController.CHANGE_DESKTOP_MODE;
 import static com.android.launcher3.util.DisplayController.CHANGE_NAVIGATION_MODE;
@@ -86,6 +89,7 @@
 import com.android.quickstep.util.ContextualSearchInvoker;
 import com.android.quickstep.util.GroupTask;
 import com.android.quickstep.views.RecentsViewContainer;
+import com.android.server.am.Flags;
 import com.android.systemui.shared.recents.model.Task;
 import com.android.systemui.shared.statusbar.phone.BarTransitions;
 import com.android.systemui.shared.system.ActivityManagerWrapper;
@@ -166,6 +170,10 @@
     private final SparseArray<DeviceProfile> mExternalDeviceProfiles = new SparseArray<>();
     private StatefulActivity mActivity;
     private RecentsViewContainer mRecentsViewContainer;
+    /** Whether this device is a desktop android device **/
+    private boolean mIsAndroidPC;
+    /** Whether this device supports freeform windows management. Can change dynamically **/
+    private boolean mSupportsFreeformWindowsManagement;
 
     /**
      * Cache a copy here so we can initialize state whenever taskbar is recreated, since
@@ -188,29 +196,29 @@
     private class RecreationListener implements DisplayController.DisplayInfoChangeListener {
         @Override
         public void onDisplayInfoChanged(Context context, DisplayController.Info info, int flags) {
+            int displayId = context.getDisplayId();
             if ((flags & CHANGE_DENSITY) != 0) {
-                debugTaskbarManager("onDisplayInfoChanged: Display density changed",
-                        context.getDisplayId());
+                debugTaskbarManager("onDisplayInfoChanged: Display density changed", displayId);
             }
             if ((flags & CHANGE_NAVIGATION_MODE) != 0) {
-                debugTaskbarManager("onDisplayInfoChanged: Navigation mode changed",
-                        context.getDisplayId());
+                debugTaskbarManager("onDisplayInfoChanged: Navigation mode changed", displayId);
             }
             if ((flags & CHANGE_DESKTOP_MODE) != 0) {
                 debugTaskbarManager("onDisplayInfoChanged: Desktop mode changed",
                         context.getDisplayId());
+                handleDisplayUpdatesForPerceptibleTasks();
             }
             if ((flags & CHANGE_TASKBAR_PINNING) != 0) {
-                debugTaskbarManager("onDisplayInfoChanged: Taskbar pinning changed",
-                        context.getDisplayId());
+                debugTaskbarManager("onDisplayInfoChanged: Taskbar pinning changed", displayId);
             }
 
             if ((flags & (CHANGE_DENSITY | CHANGE_NAVIGATION_MODE | CHANGE_DESKTOP_MODE
                     | CHANGE_TASKBAR_PINNING | CHANGE_SHOW_LOCKED_TASKBAR)) != 0) {
-                debugTaskbarManager("onDisplayInfoChanged: Recreating Taskbar!",
-                        context.getDisplayId());
+
                 TaskbarActivityContext taskbarActivityContext = getCurrentActivityContext();
                 if ((flags & CHANGE_SHOW_LOCKED_TASKBAR) != 0) {
+                    debugTaskbarManager("onDisplayInfoChanged: show locked taskbar changed!",
+                            displayId);
                     recreateTaskbars();
                 } else if ((flags & CHANGE_DESKTOP_MODE) != 0) {
                     if (mShouldIgnoreNextDesktopModeChangeFromDisplayController) {
@@ -219,7 +227,7 @@
                     }
                     // Only Handles Special Exit Cases for Desktop Mode Taskbar Recreation.
                     if (taskbarActivityContext != null
-                            && !DisplayController.showLockedTaskbarOnHome(context)) {
+                            && !taskbarActivityContext.showLockedTaskbarOnHome()) {
                         recreateTaskbars();
                     }
                 } else {
@@ -234,7 +242,7 @@
         recreateTaskbars();
     };
 
-    private final PerceptibleTaskListener mTaskStackListener;
+    private PerceptibleTaskListener mTaskStackListener;
 
     private class PerceptibleTaskListener implements TaskStackChangeListener {
         private ArraySet<Integer> mPerceptibleTasks = new ArraySet<Integer>();
@@ -288,6 +296,14 @@
         public void onTaskRemoved(int taskId) {
             mPerceptibleTasks.remove(taskId);
         }
+
+        public void unregisterListener() {
+            for (Integer taskId : mPerceptibleTasks) {
+                ActivityManagerWrapper.getInstance().setTaskIsPerceptible(taskId, false);
+            }
+            TaskStackChangeListeners.getInstance().unregisterTaskStackListener(
+                    mTaskStackListener);
+        }
     }
 
     private final DesktopVisibilityController.TaskbarDesktopModeListener
@@ -297,6 +313,11 @@
                 public void onExitDesktopMode(int duration) {
                     for (int taskbarIndex = 0; taskbarIndex < mTaskbars.size(); taskbarIndex++) {
                         int displayId = mTaskbars.keyAt(taskbarIndex);
+                        if (DesktopExperienceFlags.ENABLE_TASKBAR_CONNECTED_DISPLAYS.isTrue()
+                                && !isDefaultDisplay(displayId)) {
+                            continue;
+                        }
+
                         TaskbarActivityContext taskbarActivityContext = getTaskbarForDisplay(
                                 displayId);
                         if (taskbarActivityContext != null
@@ -316,6 +337,11 @@
                 public void onEnterDesktopMode(int duration) {
                     for (int taskbarIndex = 0; taskbarIndex < mTaskbars.size(); taskbarIndex++) {
                         int displayId = mTaskbars.keyAt(taskbarIndex);
+                        if (DesktopExperienceFlags.ENABLE_TASKBAR_CONNECTED_DISPLAYS.isTrue()
+                                && !isDefaultDisplay(displayId)) {
+                            continue;
+                        }
+
                         TaskbarActivityContext taskbarActivityContext = getTaskbarForDisplay(
                                 displayId);
                         if (taskbarActivityContext != null) {
@@ -337,7 +363,6 @@
                 }
             };
 
-
     private boolean mUserUnlocked = false;
 
     private final SimpleBroadcastReceiver mTaskbarBroadcastReceiver;
@@ -442,7 +467,7 @@
             mGrowthBroadcastReceiver =
                     new SimpleBroadcastReceiver(
                             mPrimaryWindowContext, UI_HELPER_EXECUTOR, this::showGrowthNudge);
-            mGrowthBroadcastReceiver.register(RECEIVER_EXPORTED,
+            mGrowthBroadcastReceiver.register(null, GROWTH_NUDGE_PERMISSION, RECEIVER_EXPORTED,
                     BROADCAST_SHOW_NUDGE);
         } else {
             mGrowthBroadcastReceiver = null;
@@ -457,7 +482,10 @@
             mTaskbarBroadcastReceiver.register(RECEIVER_NOT_EXPORTED, ACTION_SHOW_TASKBAR);
         });
 
-        if (ActivityManagerWrapper.usePerceptibleTasks(getPrimaryWindowContext())) {
+        mIsAndroidPC = getPrimaryWindowContext().getPackageManager().hasSystemFeature(FEATURE_PC);
+        mSupportsFreeformWindowsManagement = getFreeformWindowsManagementInfo();
+
+        if (eligibleForPerceptibleTasks()) {
             mTaskStackListener = new PerceptibleTaskListener();
             TaskStackChangeListeners.getInstance().registerTaskStackListener(mTaskStackListener);
         } else {
@@ -467,6 +495,30 @@
         debugPrimaryTaskbar("TaskbarManager created");
     }
 
+    private void handleDisplayUpdatesForPerceptibleTasks() {
+        // 1. When desktop mode changes, detect eligibility for perceptible tasks.
+        // 2. When no longer eligible for perceptible tasks, turn off and clean up.
+        mSupportsFreeformWindowsManagement = getFreeformWindowsManagementInfo();
+        if (eligibleForPerceptibleTasks()) {
+            if (mTaskStackListener == null) {
+                mTaskStackListener = new PerceptibleTaskListener();
+                TaskStackChangeListeners.getInstance()
+                        .registerTaskStackListener(mTaskStackListener);
+            }
+        } else {
+            // not eligible for perceptible tasks, so we should unregister the listener
+            if (mTaskStackListener != null) {
+                mTaskStackListener.unregisterListener();
+                mTaskStackListener = null;
+            }
+        }
+    }
+
+    private boolean getFreeformWindowsManagementInfo() {
+        return getPrimaryWindowContext().getPackageManager().hasSystemFeature(
+                FEATURE_FREEFORM_WINDOW_MANAGEMENT);
+    }
+
     private void destroyAllTaskbars() {
         debugPrimaryTaskbar("destroyAllTaskbars");
         for (int i = 0; i < mTaskbars.size(); i++) {
@@ -504,7 +556,7 @@
         debugPrimaryTaskbar("destroyTaskbarForDisplay");
         // TODO: make this code displayId specific
         TaskbarActivityContext taskbar = getTaskbarForDisplay(getDefaultDisplayId());
-        if (ACTION_SHOW_TASKBAR.equals(intent.getAction())) {
+        if (ACTION_SHOW_TASKBAR.equals(intent.getAction()) && taskbar != null) {
             taskbar.showTaskbarFromBroadcast();
         }
     }
@@ -733,8 +785,7 @@
                         displayId);
                 taskbar.updateDeviceProfile(dp);
             }
-            mSharedState.startTaskbarVariantIsTransient =
-                    DisplayController.isTransientTaskbar(taskbar);
+            mSharedState.startTaskbarVariantIsTransient = taskbar.isTransientTaskbar();
             mSharedState.allAppsVisible = mSharedState.allAppsVisible && isLargeScreenTaskbar;
             taskbar.init(mSharedState, duration);
 
@@ -988,12 +1039,12 @@
                     displayId);
             removeAndUnregisterComponentCallbacks(displayId);
 
-            debugTaskbarManager("onDisplayRemoved: destroying Taskbar!", displayId);
-            destroyTaskbarForDisplay(displayId);
-
             debugTaskbarManager("onDisplayRemoved: removing DeviceProfile from map!", displayId);
             removeDeviceProfileFromMap(displayId);
 
+            debugTaskbarManager("onDisplayRemoved: destroying Taskbar!", displayId);
+            destroyTaskbarForDisplay(displayId);
+
             debugTaskbarManager("onDisplayRemoved: removing WindowContext from map!", displayId);
             removeWindowContextFromMap(displayId);
 
@@ -1052,17 +1103,26 @@
         debugPrimaryTaskbar("destroy: unregistering component callbacks");
         removeAndUnregisterComponentCallbacks(getDefaultDisplayId());
         mShutdownReceiver.unregisterReceiverSafely();
-        if (ActivityManagerWrapper.usePerceptibleTasks(getPrimaryWindowContext())) {
-            for (Integer taskId : mTaskStackListener.mPerceptibleTasks) {
-                ActivityManagerWrapper.getInstance().setTaskIsPerceptible(taskId, false);
-            }
+        if (mTaskStackListener != null) {
+            mTaskStackListener.unregisterListener();
         }
-        TaskStackChangeListeners.getInstance().unregisterTaskStackListener(mTaskStackListener);
+
         debugPrimaryTaskbar("destroy: destroying all taskbars!");
         destroyAllTaskbars();
         debugPrimaryTaskbar("destroy: finished!");
     }
 
+    private boolean eligibleForPerceptibleTasks() {
+        // Perceptible tasks feature (oom boosting) is eligible for android PC devices, and
+        // other android devices that supports free form windows
+        //
+        // - isAndroidPC is set per device (in this case, desktop devices)
+        // - supportsFreeformWindowsManagement is dynamic, and is to be used for the use-case where
+        // user plugs in their device to external displays
+        return Flags.perceptibleTasks()
+                && (mIsAndroidPC || mSupportsFreeformWindowsManagement);
+    }
+
     public @Nullable TaskbarActivityContext getCurrentActivityContext() {
         return getTaskbarForDisplay(getDefaultDisplayId());
     }
@@ -1168,7 +1228,7 @@
      * @return The {@link TaskbarActivityContext} for the specified display, or
      * {@code null} if no taskbar is associated with that display.
      */
-    private TaskbarActivityContext getTaskbarForDisplay(int displayId) {
+    public TaskbarActivityContext getTaskbarForDisplay(int displayId) {
         return mTaskbars.get(displayId);
     }
 
@@ -1319,7 +1379,6 @@
                         }
                     }
                 } else {
-
                     getCurrentActivityContext().onConfigurationChanged(configDiff);
                 }
                 mOldConfig = new Configuration(newConfig);
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarScrimViewController.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarScrimViewController.java
index 4a7e4f0..bf73f02 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarScrimViewController.java
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarScrimViewController.java
@@ -31,7 +31,6 @@
 
 import com.android.launcher3.anim.AnimatedFloat;
 import com.android.launcher3.taskbar.bubbles.BubbleControllers;
-import com.android.launcher3.util.DisplayController;
 import com.android.quickstep.SystemUiProxy;
 import com.android.systemui.shared.system.QuickStepContract.SystemUiStateFlags;
 
@@ -93,7 +92,8 @@
             // There is no scrim for the bar in the phone mode.
             return;
         }
-        if (isBubbleBarEnabled() && DisplayController.isTransientTaskbar(mActivity)) {
+        boolean isTransient = mActivity.isTransientTaskbar();
+        if (isBubbleBarEnabled() && isTransient) {
             // These scrims aren't used if bubble bar & transient taskbar are active.
             return;
         }
@@ -112,7 +112,7 @@
         boolean showScrimForBubbles = bubblesExpanded
                 && !mTaskbarVisible
                 && isBubbleControllersPresented
-                && !DisplayController.isTransientTaskbar(mActivity)
+                && !mActivity.isTransientTaskbar()
                 && !bubbleControllers.bubbleStashController.isBubblesShowingOnHome();
         return bubblesExpanded && !mControllers.navbarButtonsViewController.isImeVisible()
                 && !isShadeVisible
@@ -122,8 +122,8 @@
     }
 
     private float computeScrimAlpha() {
-        final boolean isPersistentTaskBarVisible =
-                mTaskbarVisible && !DisplayController.isTransientTaskbar(mScrimView.getContext());
+        boolean isTransient = mActivity.isTransientTaskbar();
+        final boolean isPersistentTaskBarVisible = mTaskbarVisible && !isTransient;
         final boolean manageMenuExpanded =
                 (mSysUiStateFlags & SYSUI_STATE_BUBBLES_MANAGE_MENU_EXPANDED) != 0;
         if (isPersistentTaskBarVisible && manageMenuExpanded) {
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarSpringOnStashController.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarSpringOnStashController.java
index f87c21e..fa35a03 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarSpringOnStashController.java
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarSpringOnStashController.java
@@ -27,7 +27,6 @@
 import com.android.launcher3.anim.AnimatedFloat;
 import com.android.launcher3.anim.SpringAnimationBuilder;
 import com.android.launcher3.taskbar.TaskbarControllers.LoggableTaskbarController;
-import com.android.launcher3.util.DisplayController;
 
 import java.io.PrintWriter;
 
@@ -47,7 +46,7 @@
 
     public TaskbarSpringOnStashController(TaskbarActivityContext context) {
         mContext = context;
-        mIsTransientTaskbar = DisplayController.isTransientTaskbar(mContext);
+        mIsTransientTaskbar = context.isTransientTaskbar();
         mStartVelocityPxPerS = context.getResources()
                 .getDimension(R.dimen.transient_taskbar_stash_spring_velocity_dp_per_s);
     }
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarStashController.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarStashController.java
index 95724ad..e597148 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarStashController.java
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarStashController.java
@@ -23,10 +23,12 @@
 import static com.android.app.animation.Interpolators.LINEAR;
 import static com.android.internal.jank.InteractionJankMonitor.Configuration;
 import static com.android.launcher3.Flags.enableScalingRevealHomeAnimation;
+import static com.android.launcher3.Flags.syncAppLaunchWithTaskbarStash;
 import static com.android.launcher3.QuickstepTransitionManager.PINNED_TASKBAR_TRANSITION_DURATION;
 import static com.android.launcher3.config.FeatureFlags.ENABLE_TASKBAR_NAVBAR_UNIFICATION;
 import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_TRANSIENT_TASKBAR_HIDE;
 import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_TRANSIENT_TASKBAR_SHOW;
+import static com.android.launcher3.taskbar.TaskbarActivityContext.ENABLE_TASKBAR_BEHIND_SHADE;
 import static com.android.launcher3.util.Executors.UI_HELPER_EXECUTOR;
 import static com.android.launcher3.util.FlagDebugUtils.appendFlag;
 import static com.android.launcher3.util.FlagDebugUtils.formatFlagChange;
@@ -64,7 +66,6 @@
 import com.android.launcher3.anim.AnimatedFloat;
 import com.android.launcher3.anim.AnimationSuccessListener;
 import com.android.launcher3.anim.AnimatorListeners;
-import com.android.launcher3.util.DisplayController;
 import com.android.launcher3.util.MultiPropertyFactory.MultiProperty;
 import com.android.quickstep.SystemUiProxy;
 import com.android.quickstep.util.SystemUiFlagUtils;
@@ -107,6 +108,8 @@
     // taskbar should always be stashed for bubble bar on phone
     public static final int FLAG_STASHED_BUBBLE_BAR_ON_PHONE = 1 << 15;
 
+    public static final int FLAG_IGNORE_IN_APP = 1 << 16; // used to sync with app launch animation
+
     // If any of these flags are enabled, isInApp should return true.
     private static final int FLAGS_IN_APP = FLAG_IN_APP | FLAG_IN_SETUP;
 
@@ -303,8 +306,8 @@
         // TODO(b/390665752): Feature to "lock" pinned taskbar to home screen will be superseded by
         //     pinning, in other launcher states, at which point this variable can be removed.
         mInAppStateAffectsDesktopTasksVisibilityInTaskbar =
-                !DisplayController.showDesktopTaskbarForFreeformDisplay(mActivity)
-                        && DisplayController.showLockedTaskbarOnHome(mActivity);
+                !mActivity.showDesktopTaskbarForFreeformDisplay()
+                        && mActivity.showLockedTaskbarOnHome();
 
         mTaskbarBackgroundDuration = activity.getResources().getInteger(
                 R.integer.taskbar_background_duration);
@@ -346,7 +349,7 @@
                 StashedHandleViewController.ALPHA_INDEX_STASHED);
         mTaskbarStashedHandleHintScale = stashedHandleController.getStashedHandleHintScale();
 
-        boolean isTransientTaskbar = DisplayController.isTransientTaskbar(mActivity);
+        boolean isTransientTaskbar = mActivity.isTransientTaskbar();
         boolean isInSetup = !mActivity.isUserSetupComplete() || setupUIVisible;
         boolean isStashedInAppAuto =
                 isTransientTaskbar && !mTaskbarSharedState.getTaskbarWasPinned();
@@ -367,9 +370,7 @@
 
         // Hide the background while stashed so it doesn't show on fast swipes home
         boolean shouldHideTaskbarBackground = mActivity.isPhoneMode() ||
-                (enableScalingRevealHomeAnimation()
-                        && DisplayController.isTransientTaskbar(mActivity)
-                        && isStashed());
+                (enableScalingRevealHomeAnimation() && isTransientTaskbar && isStashed());
 
         mTaskbarBackgroundAlphaForStash.setValue(shouldHideTaskbarBackground ? 0 : 1);
 
@@ -411,11 +412,10 @@
      * Returns how long the stash/unstash animation should play.
      */
     public long getStashDuration() {
-        if (DisplayController.isPinnedTaskbar(mActivity)) {
+        if (mActivity.isPinnedTaskbar()) {
             return PINNED_TASKBAR_TRANSITION_DURATION;
         }
-        return DisplayController.isTransientTaskbar(mActivity)
-                ? TRANSIENT_TASKBAR_STASH_DURATION
+        return mActivity.isTransientTaskbar() ? TRANSIENT_TASKBAR_STASH_DURATION
                 : TASKBAR_STASH_DURATION;
     }
 
@@ -509,8 +509,8 @@
      * @see android.view.WindowInsets.Type#systemBars()
      */
     public int getContentHeightToReportToApps() {
-        if (mActivity.isUserSetupComplete() && (mActivity.isPhoneGestureNavMode()
-                || DisplayController.isTransientTaskbar(mActivity))) {
+        boolean isTransient = mActivity.isTransientTaskbar();
+        if (mActivity.isUserSetupComplete() && (mActivity.isPhoneGestureNavMode() || isTransient)) {
             return getStashedHeight();
         }
 
@@ -577,8 +577,7 @@
      */
     public void updateAndAnimateTransientTaskbar(boolean stash, boolean shouldBubblesFollow,
             boolean delayTaskbarBackground) {
-        if (!DisplayController.isTransientTaskbar(mActivity)
-                || mActivity.isBubbleBarOnPhone()) {
+        if (!mActivity.isTransientTaskbar() || mActivity.isBubbleBarOnPhone()) {
             return;
         }
 
@@ -646,7 +645,7 @@
 
     /** Toggles the Taskbar's stash state. */
     public void toggleTaskbarStash() {
-        if (!DisplayController.isTransientTaskbar(mActivity) || !hasAnyFlag(FLAGS_IN_APP)) return;
+        if (!mActivity.isTransientTaskbar() || !hasAnyFlag(FLAGS_IN_APP)) return;
         updateAndAnimateTransientTaskbar(!hasAnyFlag(FLAG_STASHED_IN_APP_AUTO));
     }
 
@@ -697,8 +696,7 @@
         mAnimator = new AnimatorSet();
         addJankMonitorListener(
                 mAnimator, /* expanding= */ !isStashed, /* tag= */ jankTag);
-        boolean isTransientTaskbar = DisplayController.isTransientTaskbar(mActivity);
-        final float stashTranslation = mActivity.isPhoneMode() || isTransientTaskbar
+        final float stashTranslation = mActivity.isPhoneMode() || mActivity.isTransientTaskbar()
                 ? 0
                 : (mUnstashedHeight - mStashedHeight);
 
@@ -722,7 +720,7 @@
             return;
         }
 
-        if (isTransientTaskbar) {
+        if (mActivity.isTransientTaskbar()) {
             createTransientAnimToIsStashed(mAnimator, isStashed, duration,
                     shouldDelayBackground, animationType);
         } else {
@@ -1140,11 +1138,14 @@
         long startDelay = 0;
 
         updateStateForFlag(FLAG_STASHED_IN_APP_SYSUI, hasAnyFlag(systemUiStateFlags,
-                SYSUI_STATE_NOTIFICATION_PANEL_VISIBLE | SYSUI_STATE_DIALOG_SHOWING));
+                SYSUI_STATE_DIALOG_SHOWING | (ENABLE_TASKBAR_BEHIND_SHADE.isTrue()
+                        ? 0
+                        : SYSUI_STATE_NOTIFICATION_PANEL_VISIBLE)
+        ));
 
         boolean stashForBubbles = hasAnyFlag(FLAG_IN_OVERVIEW)
                 && hasAnyFlag(systemUiStateFlags, SYSUI_STATE_BUBBLES_EXPANDED)
-                && DisplayController.isTransientTaskbar(mActivity);
+                && mActivity.isTransientTaskbar();
         updateStateForFlag(FLAG_STASHED_SYSUI,
                 hasAnyFlag(systemUiStateFlags, SYSUI_STATE_SCREEN_PINNING) || stashForBubbles);
         updateStateForFlag(FLAG_STASHED_DEVICE_LOCKED,
@@ -1174,7 +1175,7 @@
      * <p>Do not stash if a system gesture is started.
      */
     private boolean shouldStashForIme() {
-        if (DisplayController.isTransientTaskbar(mActivity)) {
+        if (mActivity.isTransientTaskbar()) {
             return false;
         }
         // Do not stash if in small screen, with 3 button nav, and in landscape.
@@ -1184,7 +1185,7 @@
         }
 
         // Do not stash if pinned taskbar, hardware keyboard is attached and no IME is docked
-        if (mActivity.isHardwareKeyboard() && DisplayController.isPinnedTaskbar(mActivity)
+        if (mActivity.isHardwareKeyboard() && mActivity.isPinnedTaskbar()
                 && !mActivity.isImeDocked()) {
             return false;
         }
@@ -1270,7 +1271,7 @@
      */
     public void setUpTaskbarSystemAction(boolean visible) {
         UI_HELPER_EXECUTOR.execute(() -> {
-            if (!visible || !DisplayController.isTransientTaskbar(mActivity)
+            if (!visible || !mActivity.isTransientTaskbar()
                     || mActivity.isPhoneMode()) {
                 mAccessibilityManager.unregisterSystemAction(SYSTEM_ACTION_ID_TASKBAR);
                 mIsTaskbarSystemActionRegistered = false;
@@ -1321,7 +1322,7 @@
      *                            If false, attempts to re/start the timeout
      */
     public void updateTaskbarTimeout(boolean isAutohideSuspended) {
-        if (!DisplayController.isTransientTaskbar(mActivity)) {
+        if (!mActivity.isTransientTaskbar()) {
             return;
         }
         if (isAutohideSuspended) {
@@ -1335,9 +1336,7 @@
      * Attempts to start timer to auto hide the taskbar based on time.
      */
     private void tryStartTaskbarTimeout() {
-        if (!DisplayController.isTransientTaskbar(mActivity)
-                || mIsStashed
-                || mEnableBlockingTimeoutDuringTests) {
+        if (!mActivity.isTransientTaskbar() || mIsStashed || mEnableBlockingTimeoutDuringTests) {
             return;
         }
 
@@ -1419,6 +1418,13 @@
          */
         @Nullable
         public Animator createSetStateAnimator(long flags, long duration) {
+            // We do this when we want to synchronize the app launch and taskbar stash animations.
+            if (syncAppLaunchWithTaskbarStash()
+                    && hasAnyFlag(FLAG_IGNORE_IN_APP)
+                    && hasAnyFlag(flags, FLAG_IN_APP)) {
+                flags = flags & ~FLAG_IN_APP;
+            }
+
             boolean isStashed = mStashCondition.test(flags);
 
             if (DEBUG) {
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarStashViaTouchController.kt b/quickstep/src/com/android/launcher3/taskbar/TaskbarStashViaTouchController.kt
index deaf024..df10d24 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarStashViaTouchController.kt
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarStashViaTouchController.kt
@@ -23,7 +23,6 @@
 import com.android.launcher3.touch.SingleAxisSwipeDetector
 import com.android.launcher3.touch.SingleAxisSwipeDetector.DIRECTION_NEGATIVE
 import com.android.launcher3.touch.SingleAxisSwipeDetector.VERTICAL
-import com.android.launcher3.util.DisplayController
 import com.android.launcher3.util.TouchController
 import com.android.quickstep.inputconsumers.TaskbarUnstashInputConsumer
 
@@ -39,7 +38,7 @@
 class TaskbarStashViaTouchController(val controllers: TaskbarControllers) : TouchController {
 
     private val activity: TaskbarActivityContext = controllers.taskbarActivityContext
-    private val enabled = DisplayController.isTransientTaskbar(activity)
+    private val enabled = activity.isTransientTaskbar
     private val swipeDownDetector: SingleAxisSwipeDetector
     private val translationCallback = controllers.taskbarTranslationController.transitionCallback
     /** Interpolator to apply resistance as user swipes down to the bottom of the screen. */
@@ -67,7 +66,7 @@
         val gestureHeight: Int =
             ResourceUtils.getNavbarSize(
                 ResourceUtils.NAVBAR_BOTTOM_GESTURE_SIZE,
-                activity.resources
+                activity.resources,
             )
         gestureHeightYThreshold = (activity.deviceProfile.heightPx - gestureHeight).toFloat()
     }
@@ -89,7 +88,7 @@
                         maxTouchDisplacement,
                         0f,
                         maxVisualDisplacement,
-                        displacementInterpolator
+                        displacementInterpolator,
                     )
                 )
                 return false
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarTranslationController.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarTranslationController.java
index 5a5d6d0..13fb296 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarTranslationController.java
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarTranslationController.java
@@ -29,7 +29,6 @@
 import com.android.app.animation.Interpolators;
 import com.android.launcher3.anim.AnimatedFloat;
 import com.android.launcher3.anim.SpringAnimationBuilder;
-import com.android.launcher3.util.DisplayController;
 
 import java.io.PrintWriter;
 
@@ -63,7 +62,7 @@
 
     public TaskbarTranslationController(TaskbarActivityContext context) {
         mContext = context;
-        mIsTransientTaskbar = DisplayController.isTransientTaskbar(mContext);
+        mIsTransientTaskbar = mContext.isTransientTaskbar();
         mCallback = new TransitionCallback();
     }
 
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarUIController.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarUIController.java
index ea0b81e..061a5a1 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarUIController.java
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarUIController.java
@@ -37,7 +37,6 @@
 import com.android.launcher3.model.data.ItemInfoWithIcon;
 import com.android.launcher3.popup.SystemShortcut;
 import com.android.launcher3.taskbar.bubbles.BubbleBarController;
-import com.android.launcher3.util.DisplayController;
 import com.android.launcher3.util.SplitConfigurationOptions;
 import com.android.quickstep.util.SplitTask;
 import com.android.quickstep.views.RecentsView;
@@ -116,9 +115,8 @@
      */
     public void hideOverlayWindow() {
         mControllers.keyboardQuickSwitchController.closeQuickSwitchView();
-
-        if (!DisplayController.isTransientTaskbar(mControllers.taskbarActivityContext)
-                || mControllers.taskbarAllAppsController.isOpen()) {
+        boolean isTransientTaskbar = mControllers.taskbarActivityContext.isTransientTaskbar();
+        if (!isTransientTaskbar || mControllers.taskbarAllAppsController.isOpen()) {
             mControllers.taskbarOverlayController.hideWindow();
         }
     }
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarView.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarView.java
index 93662cd..b2989cd 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarView.java
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarView.java
@@ -61,7 +61,6 @@
 import com.android.launcher3.taskbar.customization.TaskbarAllAppsButtonContainer;
 import com.android.launcher3.taskbar.customization.TaskbarDividerContainer;
 import com.android.launcher3.uioverrides.PredictedAppIcon;
-import com.android.launcher3.util.DisplayController;
 import com.android.launcher3.util.Themes;
 import com.android.launcher3.views.ActivityContext;
 import com.android.quickstep.util.GroupTask;
@@ -130,7 +129,7 @@
 
     private final int mAllAppsButtonTranslationOffset;
 
-    private final int mNumStaticViews;
+    private int mNumStaticViews;
 
     private Set<GroupTask> mPrevRecentTasks = Collections.emptySet();
     private Set<GroupTask> mPrevOverflowTasks = Collections.emptySet();
@@ -184,8 +183,9 @@
         setWillNotDraw(false);
 
         mAllAppsButtonContainer = new TaskbarAllAppsButtonContainer(context);
-        mAllAppsButtonTranslationOffset =  (int) getResources().getDimension(
-                mAllAppsButtonContainer.getAllAppsButtonTranslationXOffset(isTransientTaskbar()));
+        mAllAppsButtonTranslationOffset = (int) getResources().getDimension(
+                mAllAppsButtonContainer.getAllAppsButtonTranslationXOffset(
+                        mActivityContext.isTransientTaskbar()));
 
         if (enableTaskbarPinning() || enableRecentsInTaskbar()) {
             mTaskbarDividerContainer = new TaskbarDividerContainer(context);
@@ -199,8 +199,6 @@
 
         // TODO: Disable touch events on QSB otherwise it can crash.
         mQsb = LayoutInflater.from(context).inflate(R.layout.search_container_hotseat, this, false);
-
-        mNumStaticViews = ENABLE_TASKBAR_RECENTS_LAYOUT_TRANSITION.isTrue() ? addStaticViews() : 0;
     }
 
     /**
@@ -240,7 +238,7 @@
                 enableTaskbarPinning() && !mActivityContext.isThreeButtonNav();
         availableWidth -= iconSize - (int) getResources().getDimension(
                 mAllAppsButtonContainer.getAllAppsButtonTranslationXOffset(
-                        forceTransientTaskbarSize || isTransientTaskbar()));
+                        forceTransientTaskbarSize || mActivityContext.isTransientTaskbar()));
         ++additionalIcons;
 
         return Math.floorDiv(availableWidth, iconSize) + additionalIcons;
@@ -370,23 +368,9 @@
         if (!(view.getTag() instanceof CollectionInfo)) {
             mActivityContext.getViewCache().recycleView(view.getSourceLayoutResId(), view);
         }
-        if (view instanceof FolderIcon fi) {
-            // We should clear FolderInfo's Folder and FolderIcon to avoid memory leak.
-            fi.removeListeners();
-        }
         view.setTag(null);
     }
 
-    /** Loop through all {@link FolderIcon} as child views and clear listeners to avoid leak. */
-    public void removeFolderIconListeners() {
-        final int childCount = getChildCount();
-        for (int i = 0; i < childCount; i++) {
-            if (getChildAt(i) instanceof FolderIcon fi) {
-                fi.removeListeners();
-            }
-        }
-    }
-
     /** Inflates/binds the hotseat items and recent tasks to the view. */
     protected void updateItems(ItemInfo[] hotseatItemInfos, List<GroupTask> recentTasks) {
         if (mActivityContext.isDestroyed()) return;
@@ -447,6 +431,9 @@
 
     private void updateItemsWithLayoutTransition(
             ItemInfo[] hotseatItemInfos, List<GroupTask> recentTasks) {
+        if (mNumStaticViews == 0) {
+            mNumStaticViews = addStaticViews();
+        }
 
         // Skip static views and potential All Apps divider, if they are on the left.
         mNextViewIndex = mIsRtl ? 0 : mNumStaticViews;
@@ -475,7 +462,7 @@
         }
 
         // Recents divider takes priority.
-        if (!mAddedDividerForRecents && !mActivityContext.areDesktopTasksVisible()) {
+        if (!mAddedDividerForRecents && !mActivityContext.isInDesktopMode()) {
             updateAllAppsDivider();
         }
     }
@@ -577,6 +564,9 @@
                 LayoutParams lp = new LayoutParams(mIconTouchSize, mIconTouchSize);
                 hotseatView.setPadding(mItemPadding, mItemPadding, mItemPadding, mItemPadding);
                 addView(hotseatView, mNextViewIndex, lp);
+            } else if (hotseatView instanceof FolderIcon fi) {
+                fi.onItemsChanged(false);
+                fi.getFolder().reapplyItemInfo();
             }
 
             // Apply the Hotseat ItemInfos, or hide the view if there is none for a given index.
@@ -1098,11 +1088,6 @@
         // Ignore, we just implement Insettable to draw behind system insets.
     }
 
-    private boolean isTransientTaskbar() {
-        return DisplayController.isTransientTaskbar(mActivityContext)
-                && !mActivityContext.isPhoneMode();
-    }
-
     public boolean areIconsVisible() {
         // Consider the overall visibility
         return getVisibility() == VISIBLE;
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarViewCallbacks.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarViewCallbacks.java
index dcb9fbf..d0886e0 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarViewCallbacks.java
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarViewCallbacks.java
@@ -36,7 +36,6 @@
 
 import com.android.internal.jank.Cuj;
 import com.android.launcher3.taskbar.bubbles.BubbleBarViewController;
-import com.android.launcher3.util.DisplayController;
 import com.android.systemui.shared.system.InteractionJankMonitorWrapper;
 import com.android.wm.shell.shared.bubbles.BubbleBarLocation;
 
@@ -67,8 +66,8 @@
         InteractionJankMonitorWrapper.begin(v, Cuj.CUJ_LAUNCHER_OPEN_ALL_APPS,
                 /* tag= */ "TASKBAR_BUTTON");
         mActivity.getStatsLogManager().logger().log(LAUNCHER_TASKBAR_ALLAPPS_BUTTON_TAP);
-        if (DisplayController.showLockedTaskbarOnHome(mActivity)
-                || DisplayController.showDesktopTaskbarForFreeformDisplay(mActivity)) {
+        if (mActivity.showLockedTaskbarOnHome()
+                || mActivity.showDesktopTaskbarForFreeformDisplay()) {
             // If the taskbar can be shown on the home screen, use mAllAppsToggler to toggle all
             // apps, which will toggle the launcher activity all apps when on home screen.
             // TODO(b/395913143): Reconsider this if a gap in taskbar all apps functionality that
@@ -248,8 +247,7 @@
 
         /** Returns true if the taskbar pinning popup view was shown for {@code event}. */
         private boolean maybeShowPinningView(@NonNull MotionEvent event) {
-            if (!DisplayController.isPinnedTaskbar(mActivity) || mTaskbarView.isEventOverAnyItem(
-                    event)) {
+            if (!mActivity.isPinnedTaskbar() || mTaskbarView.isEventOverAnyItem(event)) {
                 return false;
             }
             mControllers.taskbarPinningController.showPinningView(mTaskbarView, event.getRawX());
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarViewController.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarViewController.java
index a80e2c4..c5b97e7 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarViewController.java
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarViewController.java
@@ -19,6 +19,7 @@
 import static android.animation.LayoutTransition.CHANGE_APPEARING;
 import static android.animation.LayoutTransition.CHANGE_DISAPPEARING;
 import static android.animation.LayoutTransition.DISAPPEARING;
+import static android.view.Display.DEFAULT_DISPLAY;
 import static android.window.DesktopModeFlags.ENABLE_TASKBAR_RECENTS_LAYOUT_TRANSITION;
 
 import static com.android.app.animation.Interpolators.EMPHASIZED;
@@ -86,7 +87,6 @@
 import com.android.launcher3.taskbar.bubbles.BubbleControllers;
 import com.android.launcher3.taskbar.customization.TaskbarAllAppsButtonContainer;
 import com.android.launcher3.taskbar.customization.TaskbarDividerContainer;
-import com.android.launcher3.util.DisplayController;
 import com.android.launcher3.util.ItemInfoMatcher;
 import com.android.launcher3.util.LauncherBindableItemsContainer;
 import com.android.launcher3.util.MultiPropertyFactory;
@@ -267,9 +267,8 @@
                 : mActivity.getDeviceProfile().taskbarHeight;
 
         mTaskbarIconScaleForStash.updateValue(1f);
-        float pinningValue = DisplayController.isTransientTaskbar(mActivity)
-                ? PINNING_TRANSIENT
-                : PINNING_PERSISTENT;
+        float pinningValue =
+                mActivity.isTransientTaskbar() ? PINNING_TRANSIENT : PINNING_PERSISTENT;
         mTaskbarIconScaleForPinning.updateValue(pinningValue);
         mTaskbarIconTranslationYForPinning.updateValue(pinningValue);
         mTaskbarIconTranslationXForPinning.updateValue(pinningValue);
@@ -394,7 +393,6 @@
         if (enableTaskbarPinning()) {
             mTaskbarView.removeOnLayoutChangeListener(mTaskbarViewLayoutChangeListener);
         }
-        mTaskbarView.removeFolderIconListeners();
         LauncherAppState.getInstance(mActivity).getModel().removeCallbacks(mModelCallbacks);
         mActivity.removeOnDeviceProfileChangeListener(mDeviceProfileChangeListener);
     }
@@ -749,7 +747,8 @@
     }
 
     private boolean shouldUpdateIconContentDescription(BubbleTextView btv) {
-        boolean isInDesktopMode = mControllers.taskbarDesktopModeController.isInDesktopMode();
+        boolean isInDesktopMode = mControllers.taskbarDesktopModeController.isInDesktopMode(
+                DEFAULT_DISPLAY);
         boolean isAllAppsButton = btv instanceof TaskbarAllAppsButtonContainer;
         boolean isDividerButton = btv instanceof TaskbarDividerContainer;
         return isInDesktopMode && !isAllAppsButton && !isDividerButton;
@@ -932,11 +931,13 @@
     private AnimatorPlaybackController createIconAlignmentController(DeviceProfile launcherDp) {
         PendingAnimation setter = new PendingAnimation(100);
         // icon alignment not needed for pinned taskbar.
-        if (DisplayController.isPinnedTaskbar(mActivity)) return setter.createPlaybackController();
+        if (mActivity.isPinnedTaskbar()) {
+            return setter.createPlaybackController();
+        }
         mOnControllerPreCreateCallback.run();
         DeviceProfile taskbarDp = mActivity.getDeviceProfile();
         Rect hotseatPadding = launcherDp.getHotseatLayoutPadding(mActivity);
-        boolean isTransientTaskbar = DisplayController.isTransientTaskbar(mActivity);
+        boolean isTransientTaskbar = mActivity.isTransientTaskbar();
 
         float scaleUp = ((float) launcherDp.iconSizePx) / taskbarDp.taskbarIconSize;
         int borderSpacing = launcherDp.hotseatBorderSpace;
diff --git a/quickstep/src/com/android/launcher3/taskbar/VoiceInteractionWindowController.kt b/quickstep/src/com/android/launcher3/taskbar/VoiceInteractionWindowController.kt
index c380c8d..c7d42b1 100644
--- a/quickstep/src/com/android/launcher3/taskbar/VoiceInteractionWindowController.kt
+++ b/quickstep/src/com/android/launcher3/taskbar/VoiceInteractionWindowController.kt
@@ -22,7 +22,6 @@
 import android.view.ViewTreeObserver.InternalInsetsInfo.TOUCHABLE_INSETS_REGION
 import android.view.WindowManager
 import android.view.WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY
-import com.android.launcher3.util.DisplayController
 import com.android.launcher3.views.BaseDragLayer
 import com.android.systemui.animation.ViewRootSync
 import java.io.PrintWriter
@@ -41,8 +40,7 @@
 class VoiceInteractionWindowController(val context: TaskbarActivityContext) :
     TaskbarControllers.LoggableTaskbarController, TaskbarControllers.BackgroundRendererController {
 
-    private val isSeparateBackgroundEnabled =
-        !DisplayController.isTransientTaskbar(context) && !context.isPhoneMode
+    private val isSeparateBackgroundEnabled = !context.isTransientTaskbar && !context.isPhoneMode
     private val taskbarBackgroundRenderer = TaskbarBackgroundRenderer(context)
     private val nonTouchableInsetsComputer =
         ViewTreeObserver.OnComputeInternalInsetsListener {
@@ -97,7 +95,7 @@
         separateWindowLayoutParams =
             context.createDefaultWindowLayoutParams(
                 TYPE_APPLICATION_OVERLAY,
-                TEMP_BACKGROUND_WINDOW_TITLE
+                TEMP_BACKGROUND_WINDOW_TITLE,
             )
         separateWindowLayoutParams?.isSystemApplicationOverlay = true
     }
@@ -163,7 +161,7 @@
                 // First add the temporary window, then hide the overlapping taskbar background.
                 context.addWindowView(
                     separateWindowForTaskbarBackground,
-                    separateWindowLayoutParams
+                    separateWindowLayoutParams,
                 );
                 { controllers.taskbarDragLayerController.setIsBackgroundDrawnElsewhere(true) }
             } else {
@@ -179,7 +177,7 @@
                 ViewRootSync.synchronizeNextDraw(
                     separateWindowForTaskbarBackground!!,
                     context.dragLayer,
-                    onWindowsSynchronized
+                    onWindowsSynchronized,
                 )
             }
         }
diff --git a/quickstep/src/com/android/launcher3/taskbar/allapps/TaskbarAllAppsSlideInView.java b/quickstep/src/com/android/launcher3/taskbar/allapps/TaskbarAllAppsSlideInView.java
index 5830095..916b28e 100644
--- a/quickstep/src/com/android/launcher3/taskbar/allapps/TaskbarAllAppsSlideInView.java
+++ b/quickstep/src/com/android/launcher3/taskbar/allapps/TaskbarAllAppsSlideInView.java
@@ -15,7 +15,9 @@
  */
 package com.android.launcher3.taskbar.allapps;
 
+import static com.android.app.animation.Interpolators.DECELERATED_EASE;
 import static com.android.app.animation.Interpolators.EMPHASIZED;
+import static com.android.app.animation.Interpolators.LINEAR;
 import static com.android.launcher3.touch.AllAppsSwipeController.ALL_APPS_FADE_MANUAL;
 import static com.android.launcher3.touch.AllAppsSwipeController.SCRIM_FADE_MANUAL;
 
@@ -35,6 +37,7 @@
 
 import com.android.app.animation.Interpolators;
 import com.android.launcher3.DeviceProfile;
+import com.android.launcher3.Flags;
 import com.android.launcher3.Insettable;
 import com.android.launcher3.R;
 import com.android.launcher3.anim.AnimatorListeners;
@@ -48,9 +51,11 @@
 public class TaskbarAllAppsSlideInView extends AbstractSlideInView<TaskbarOverlayContext>
         implements Insettable, DeviceProfile.OnDeviceProfileChangeListener {
     private final Handler mHandler;
+    private final int mMaxBlurRadius;
 
     private TaskbarAllAppsContainerView mAppsView;
     private float mShiftRange;
+    private int mBlurRadius;
     private @Nullable Runnable mShowOnFullyAttachedToWindowRunnable;
 
     // Initialized in init.
@@ -64,6 +69,8 @@
             int defStyleAttr) {
         super(context, attrs, defStyleAttr);
         mHandler = new Handler(Looper.myLooper());
+        mMaxBlurRadius = getResources().getDimensionPixelSize(
+                R.dimen.max_depth_blur_radius_enhanced);
     }
 
     void init(TaskbarAllAppsCallbacks callbacks) {
@@ -99,6 +106,7 @@
         if (!animate) {
             mAllAppsCallbacks.onAllAppsTransitionEnd(true);
             setTranslationShift(TRANSLATION_SHIFT_OPENED);
+            mBlurRadius = mMaxBlurRadius;
             return;
         }
 
@@ -123,6 +131,16 @@
             animation.setViewAlpha(mAppsView, 1 - mToTranslationShift, allAppsFadeInterpolator);
         }
 
+        if (Flags.allAppsBlur()) {
+            Interpolator blurInterpolator = isOpening ? LINEAR : DECELERATED_EASE;
+            animation.addOnFrameListener(a -> {
+                float blurProgress =
+                        isOpening ? a.getAnimatedFraction() : 1 - a.getAnimatedFraction();
+                mBlurRadius =
+                        (int) (mMaxBlurRadius * blurInterpolator.getInterpolation(blurProgress));
+            });
+        }
+
         mAllAppsCallbacks.onAllAppsAnimationPending(animation, isOpening);
     }
 
@@ -219,6 +237,7 @@
         // to pass extra bottom offset to background scrim to fill the bottom gap during predictive
         // back swipe.
         mAppsView.drawOnScrimWithBottomOffset(canvas, getBottomOffsetPx());
+        mActivityContext.getOverlayController().setBackgroundBlurRadius(mBlurRadius);
         super.dispatchDraw(canvas);
     }
 
@@ -230,9 +249,13 @@
 
     @Override
     protected int getScrimColor(Context context) {
-        return mActivityContext.getDeviceProfile().isPhone
-                ? Themes.getAttrColor(context, R.attr.allAppsScrimColor)
-                : context.getColor(R.color.widgets_picker_scrim);
+        if (!mActivityContext.getDeviceProfile().shouldShowAllAppsOnSheet()) {
+            return Themes.getAttrColor(context, R.attr.allAppsScrimColor);
+        }
+        if (Flags.allAppsBlur()) {
+            return Themes.getAttrColor(context, R.attr.allAppsScrimColorOverBlur);
+        }
+        return context.getResources().getColor(R.color.widgets_picker_scrim);
     }
 
     @Override
@@ -254,6 +277,7 @@
     public void onDeviceProfileChanged(DeviceProfile dp) {
         setShiftRange(dp.allAppsShiftRange);
         setTranslationShift(TRANSLATION_SHIFT_OPENED);
+        mBlurRadius = mMaxBlurRadius;
     }
 
     private void setShiftRange(float shiftRange) {
diff --git a/quickstep/src/com/android/launcher3/taskbar/allapps/TaskbarAllAppsViewController.java b/quickstep/src/com/android/launcher3/taskbar/allapps/TaskbarAllAppsViewController.java
index 52f7176..f1ccd39 100644
--- a/quickstep/src/com/android/launcher3/taskbar/allapps/TaskbarAllAppsViewController.java
+++ b/quickstep/src/com/android/launcher3/taskbar/allapps/TaskbarAllAppsViewController.java
@@ -31,7 +31,6 @@
 import com.android.launcher3.taskbar.TaskbarStashController;
 import com.android.launcher3.taskbar.overlay.TaskbarOverlayContext;
 import com.android.launcher3.taskbar.overlay.TaskbarOverlayController;
-import com.android.launcher3.util.DisplayController;
 import com.android.systemui.shared.system.InteractionJankMonitorWrapper;
 
 import java.util.Optional;
@@ -90,7 +89,7 @@
     }
 
     private void setUpTaskbarStashing() {
-        if (DisplayController.isTransientTaskbar(mContext)) {
+        if (mContext.isTransientTaskbar()) {
             mTaskbarStashController.updateStateForFlag(FLAG_STASHED_IN_TASKBAR_ALL_APPS, true);
             mTaskbarStashController.applyState();
         }
@@ -103,7 +102,7 @@
             AbstractFloatingView.closeOpenContainer(
                     mContext, AbstractFloatingView.TYPE_ACTION_POPUP);
 
-            if (DisplayController.isTransientTaskbar(mContext)) {
+            if (mContext.isTransientTaskbar()) {
                 mTaskbarStashController.updateStateForFlag(FLAG_STASHED_IN_TASKBAR_ALL_APPS, false);
                 mTaskbarStashController.applyState();
             }
diff --git a/quickstep/src/com/android/launcher3/taskbar/bubbles/BubbleBarLocationDropTarget.kt b/quickstep/src/com/android/launcher3/taskbar/bubbles/BubbleBarLocationDropTarget.kt
index 383f4d2..24e7d99 100644
--- a/quickstep/src/com/android/launcher3/taskbar/bubbles/BubbleBarLocationDropTarget.kt
+++ b/quickstep/src/com/android/launcher3/taskbar/bubbles/BubbleBarLocationDropTarget.kt
@@ -60,8 +60,6 @@
 
     override fun onDrop(dragObject: DropTarget.DragObject, options: DragOptions) {
         val itemInfo = dragObject.dragInfo ?: return
-        // TODO(b/397459664) : fix task bar icon animation after drop
-        // TODO(b/397459664) : update bubble bar location
         bubbleBarDragListener.onLauncherItemDroppedOverBubbleBarDragZone(
             bubbleBarLocation,
             itemInfo,
@@ -77,8 +75,6 @@
     }
 
     override fun onDragExit(dragObject: DropTarget.DragObject) {
-        // TODO(b/397459664) : fix the issue for no bubbles, when moving task bar icon out of
-        // the bubble bar drag zone drag ends and swipes gesture swipes the overview
         if (!isShowingDropTarget) return
         isShowingDropTarget = false
         bubbleBarDragListener.onLauncherItemDraggedOutsideBubbleBarDropZone()
diff --git a/quickstep/src/com/android/launcher3/taskbar/bubbles/BubbleBarView.java b/quickstep/src/com/android/launcher3/taskbar/bubbles/BubbleBarView.java
index d43ebe2..1abef8a 100644
--- a/quickstep/src/com/android/launcher3/taskbar/bubbles/BubbleBarView.java
+++ b/quickstep/src/com/android/launcher3/taskbar/bubbles/BubbleBarView.java
@@ -204,7 +204,7 @@
         mExpandedBarIconsSpacing = getResources().getDimensionPixelSize(
                 R.dimen.bubblebar_expanded_icon_spacing);
         mBubbleElevation = getResources().getDimensionPixelSize(R.dimen.bubblebar_icon_elevation);
-        mDragElevation = getResources().getDimensionPixelSize(R.dimen.bubblebar_drag_elevation);
+        mDragElevation = getResources().getDimensionPixelSize(R.dimen.dragged_bubble_elevation);
         mPointerSize = getResources()
                 .getDimensionPixelSize(R.dimen.bubblebar_pointer_visible_size);
 
diff --git a/quickstep/src/com/android/launcher3/taskbar/bubbles/BubbleBarViewController.java b/quickstep/src/com/android/launcher3/taskbar/bubbles/BubbleBarViewController.java
index 277dbbf..9fb283c 100644
--- a/quickstep/src/com/android/launcher3/taskbar/bubbles/BubbleBarViewController.java
+++ b/quickstep/src/com/android/launcher3/taskbar/bubbles/BubbleBarViewController.java
@@ -41,15 +41,16 @@
 import androidx.annotation.Nullable;
 
 import com.android.app.animation.Interpolators;
+import com.android.launcher3.AbstractFloatingView;
 import com.android.launcher3.DeviceProfile;
 import com.android.launcher3.R;
 import com.android.launcher3.anim.AnimatedFloat;
 import com.android.launcher3.anim.RoundedRectRevealOutlineProvider;
+import com.android.launcher3.dragndrop.DragController;
 import com.android.launcher3.model.data.ItemInfo;
 import com.android.launcher3.model.data.WorkspaceItemInfo;
 import com.android.launcher3.taskbar.TaskbarActivityContext;
 import com.android.launcher3.taskbar.TaskbarControllers;
-import com.android.launcher3.taskbar.TaskbarDragController;
 import com.android.launcher3.taskbar.TaskbarInsetsController;
 import com.android.launcher3.taskbar.TaskbarSharedState;
 import com.android.launcher3.taskbar.TaskbarStashController;
@@ -144,6 +145,7 @@
         @Override
         public void onLauncherItemDroppedOverBubbleBarDragZone(@NonNull BubbleBarLocation location,
                 @NonNull ItemInfo itemInfo) {
+            AbstractFloatingView.closeAllOpenViews(mActivity);
             if (itemInfo instanceof WorkspaceItemInfo) {
                 ShortcutInfo shortcutInfo = ((WorkspaceItemInfo) itemInfo).getDeepShortcutInfo();
                 if (shortcutInfo != null) {
@@ -193,13 +195,13 @@
     private boolean mShouldShowEducation;
     public boolean mOverflowAdded;
     private boolean mIsLocationUpdatedForDropTarget = false;
+    private boolean mWasStashedBeforeEnteringBubbleDragZone = false;
 
     private BubbleBarViewAnimator mBubbleBarViewAnimator;
     private final FrameLayout mBubbleBarContainer;
     private BubbleBarFlyoutController mBubbleBarFlyoutController;
     private BubbleBarPinController mBubbleBarPinController;
     private TaskbarSharedState mTaskbarSharedState;
-    private TaskbarDragController mTaskbarDragController;
     private final BubbleBarLocationDropTarget mBubbleBarLeftDropTarget;
     private final BubbleBarLocationDropTarget mBubbleBarRightDropTarget;
     private final TimeSource mTimeSource = System::currentTimeMillis;
@@ -220,7 +222,7 @@
         mIconSize = res.getDimensionPixelSize(R.dimen.bubblebar_icon_size);
         mBubbleBarTaskbarMinDistance = res.getDimensionPixelSize(
                 R.dimen.bubblebar_transient_taskbar_min_distance);
-        mDragElevation = res.getDimensionPixelSize(R.dimen.bubblebar_drag_elevation);
+        mDragElevation = res.getDimensionPixelSize(R.dimen.dragged_bubble_elevation);
         mTaskbarTranslationDelta = getBubbleBarTranslationDeltaForTaskbar(activity);
         if (DeviceConfig.isSmallTablet(mActivity)) {
             mBubbleBarDropTargetSize = res.getDimensionPixelSize(R.dimen.drag_zone_bubble_fold);
@@ -236,7 +238,6 @@
     /** Initializes controller. */
     public void init(TaskbarControllers controllers, BubbleControllers bubbleControllers,
             TaskbarViewPropertiesProvider taskbarViewPropertiesProvider) {
-        mTaskbarDragController = controllers.taskbarDragController;
         mTaskbarSharedState = controllers.getSharedState();
         mBubbleStashController = bubbleControllers.bubbleStashController;
         mBubbleBarController = bubbleControllers.bubbleBarController;
@@ -273,7 +274,7 @@
                         mBoundsChangeListener.onBoundsChanged();
                     }
                 });
-        float pinningValue = DisplayController.isTransientTaskbar(mActivity)
+        float pinningValue = mActivity.isTransientTaskbar()
                 ? PINNING_TRANSIENT
                 : PINNING_PERSISTENT;
         mBubbleBarPinning.updateValue(pinningValue);
@@ -338,8 +339,18 @@
                 mBubbleBarController.updateBubbleBarLocation(location, source);
             }
         };
-        mTaskbarDragController.addDropTarget(mBubbleBarLeftDropTarget);
-        mTaskbarDragController.addDropTarget(mBubbleBarRightDropTarget);
+    }
+
+    /** Adds bubble bar locations drop zones to the drag controller. */
+    public void addBubbleBarDropTargets(DragController<?> dragController) {
+        dragController.addDropTarget(mBubbleBarLeftDropTarget);
+        dragController.addDropTarget(mBubbleBarRightDropTarget);
+    }
+
+    /** Removes bubble bar locations drop zones to the drag controller. */
+    public void removeBubbleBarDropTargets(DragController<?> dragController) {
+        dragController.removeDropTarget(mBubbleBarLeftDropTarget);
+        dragController.removeDropTarget(mBubbleBarRightDropTarget);
     }
 
     /** Returns animated float property responsible for pinning transition animation. */
@@ -617,14 +628,30 @@
      * updated.
      */
     public void onDragItemOverBubbleBarDragZone(@NonNull BubbleBarLocation bubbleBarLocation) {
+        Log.w("BBAnimation", "onDragItemOverBubbleBarDragZone()");
         mBarView.showDropTarget(/* isDropTarget = */ true);
         boolean isRtl = mBarView.isLayoutRtl();
         mIsLocationUpdatedForDropTarget = getBubbleBarLocation().isOnLeft(isRtl)
                 != bubbleBarLocation.isOnLeft(isRtl);
-        if (mIsLocationUpdatedForDropTarget) {
-            animateBubbleBarLocation(bubbleBarLocation);
-        }
-        if (!hasBubbles()) {
+        mWasStashedBeforeEnteringBubbleDragZone = hasBubbles()
+            && mBubbleStashController.isStashed();
+        if (mWasStashedBeforeEnteringBubbleDragZone) {
+            if (mIsLocationUpdatedForDropTarget) {
+                // bubble bar is stashed an location updated
+                //TODO(b/399678274) add animation
+                mBubbleStashController.showBubbleBarImmediate();
+                animateBubbleBarLocation(bubbleBarLocation);
+            } else {
+                // bubble bar is stashed and location the same - just un-stash
+                mBubbleStashController.showBubbleBar(/* expandBubbles = */ false);
+            }
+        } else if (hasBubbles()) {
+            if (mIsLocationUpdatedForDropTarget) {
+                // bubble bar has bubbles and location is changed - animate bar to the opposite side
+                animateBubbleBarLocation(bubbleBarLocation);
+            }
+        } else {
+            // bubble bar has no bubbles flow just show the empty drop target
             mBubbleBarPinController.showDropTarget(bubbleBarLocation);
         }
     }
@@ -644,12 +671,27 @@
      * mode and reset the value returned from {@link #isLocationUpdatedForDropTarget()} to false.
      */
     public void onItemDraggedOutsideBubbleBarDropZone() {
+        Log.w("BBAnimation", "onItemDraggedOutsideBubbleBarDropZone()");
         mBarView.showDropTarget(/* isDropTarget = */ false);
-        if (mIsLocationUpdatedForDropTarget) {
-            animateBubbleBarLocation(getBubbleBarLocation());
+        if (mWasStashedBeforeEnteringBubbleDragZone) {
+            if (mIsLocationUpdatedForDropTarget) {
+                // bubble bar was stashed and location updated
+                //TODO(b/399678274) add animation
+                animateBubbleBarLocation(getBubbleBarLocation());
+                mBubbleStashController.stashBubbleBarImmediate();
+            } else {
+                // bubble bar was stashed and location the same - just stash it back
+                mBubbleStashController.stashBubbleBar();
+            }
+        } else if (hasBubbles()) {
+            if (mIsLocationUpdatedForDropTarget) {
+                // bubble bar has bubbles and location was changed - return to the original location
+                animateBubbleBarLocation(getBubbleBarLocation());
+            }
         }
         mBubbleBarPinController.hideDropTarget();
         mIsLocationUpdatedForDropTarget = false;
+        mWasStashedBeforeEnteringBubbleDragZone = false;
     }
 
     /**
@@ -657,9 +699,11 @@
      * The controller will hide the drop target if there are no bubbles and exit drop target mode.
      */
     public void onItemDroppedInBubbleBarDragZone() {
+        Log.w("BBAnimation", "onItemDroppedInBubbleBarDragZone()");
         mBarView.showDropTarget(/* isDropTarget = */ false);
         mBubbleBarPinController.hideDropTarget();
         mIsLocationUpdatedForDropTarget = false;
+        mWasStashedBeforeEnteringBubbleDragZone = false;
     }
 
     /**
@@ -1356,20 +1400,18 @@
     /** Called when the controller is destroyed. */
     public void onDestroy() {
         adjustTaskbarAndHotseatToBubbleBarState(/*isBubbleBarExpanded = */false);
-        mTaskbarDragController.removeDropTarget(mBubbleBarLeftDropTarget);
-        mTaskbarDragController.removeDropTarget(mBubbleBarRightDropTarget);
     }
 
     /**
      * Removes the bubble from the bubble bar and notifies sysui that the bubble should move to
      * full screen.
      */
-    public void moveBubbleToFullscreen(@NonNull BubbleView bubbleView) {
+    public void moveDraggedBubbleToFullscreen(@NonNull BubbleView bubbleView, Point dropLocation) {
         if (bubbleView.getBubble() == null) {
             return;
         }
         String key = bubbleView.getBubble().getKey();
-        mSystemUiProxy.moveBubbleToFullscreen(key);
+        mSystemUiProxy.moveDraggedBubbleToFullscreen(key, dropLocation);
         onBubbleDismissed(bubbleView);
     }
 
diff --git a/quickstep/src/com/android/launcher3/taskbar/bubbles/BubbleDragController.java b/quickstep/src/com/android/launcher3/taskbar/bubbles/BubbleDragController.java
index f77b934..3df10c0 100644
--- a/quickstep/src/com/android/launcher3/taskbar/bubbles/BubbleDragController.java
+++ b/quickstep/src/com/android/launcher3/taskbar/bubbles/BubbleDragController.java
@@ -16,6 +16,7 @@
 package com.android.launcher3.taskbar.bubbles;
 
 import android.annotation.SuppressLint;
+import android.graphics.Point;
 import android.graphics.PointF;
 import android.view.MotionEvent;
 import android.view.VelocityTracker;
@@ -231,13 +232,14 @@
             }
 
             @Override
-            void onDragEnd() {
+            void onDragEnd(float x, float y) {
                 mBubbleBarController.updateBubbleBarLocation(getBubbleBarLocationDuringDrag(),
                         BubbleBarLocation.UpdateSource.DRAG_BUBBLE);
                 if (BubbleAnythingFlagHelper.enableBubbleToFullscreen()) {
                     mDropTargetManager.onDragEnded();
                     if (mBubbleDragZoneChangedListener.isDraggedToFullscreen()) {
-                        mBubbleBarViewController.moveBubbleToFullscreen(bubbleView);
+                        mBubbleBarViewController.moveDraggedBubbleToFullscreen(
+                                bubbleView, new Point((int) x, (int) y));
                     }
                 } else {
                     mBubblePinController.setListener(null);
@@ -329,7 +331,7 @@
             }
 
             @Override
-            void onDragEnd() {
+            void onDragEnd(float x, float y) {
                 // Make sure to update location as the first thing. Pivot update causes a relayout
                 mBubbleBarController.updateBubbleBarLocation(getBubbleBarLocationDuringDrag(),
                         BubbleBarLocation.UpdateSource.DRAG_BAR);
@@ -428,7 +430,7 @@
         /**
          * Called when the dragging interaction has ended and all the animations have completed
          */
-        abstract void onDragEnd();
+        abstract void onDragEnd(float x, float y);
 
         /**
          * Called when the dragged bubble is released outside of the dismiss target area and will
@@ -579,7 +581,7 @@
             Runnable onComplete = () -> {
                 mActivity.setTaskbarWindowFullscreen(false);
                 cleanUp(view);
-                onDragEnd();
+                onDragEnd(event.getRawX(), event.getRawY());
             };
 
             if (mBubbleDismissController.handleTouchEvent(event)) {
diff --git a/quickstep/src/com/android/launcher3/taskbar/bubbles/flyout/BubbleBarFlyoutView.kt b/quickstep/src/com/android/launcher3/taskbar/bubbles/flyout/BubbleBarFlyoutView.kt
index 75bf937..ac87b5e 100644
--- a/quickstep/src/com/android/launcher3/taskbar/bubbles/flyout/BubbleBarFlyoutView.kt
+++ b/quickstep/src/com/android/launcher3/taskbar/bubbles/flyout/BubbleBarFlyoutView.kt
@@ -36,6 +36,8 @@
 import androidx.core.animation.ArgbEvaluator
 import com.android.launcher3.R
 import com.android.launcher3.popup.RoundedArrowDrawable
+import com.android.wm.shell.shared.TypefaceUtils
+import com.android.wm.shell.shared.TypefaceUtils.Companion.setTypeface
 import kotlin.math.min
 
 /** The flyout view used to notify the user of a new bubble notification. */
@@ -163,6 +165,9 @@
         LayoutInflater.from(context).inflate(R.layout.bubblebar_flyout, this, true)
         id = R.id.bubble_bar_flyout_view
 
+        setTypeface(title, TypefaceUtils.FontFamily.GSF_LABEL_LARGE)
+        setTypeface(message, TypefaceUtils.FontFamily.GSF_BODY_MEDIUM)
+
         val ta = context.obtainStyledAttributes(intArrayOf(android.R.attr.dialogCornerRadius))
         cornerRadius = ta.getDimensionPixelSize(0, 0).toFloat()
         ta.recycle()
diff --git a/quickstep/src/com/android/launcher3/taskbar/customization/TaskbarAllAppsButtonContainer.kt b/quickstep/src/com/android/launcher3/taskbar/customization/TaskbarAllAppsButtonContainer.kt
index 4932654..a1df21f 100644
--- a/quickstep/src/com/android/launcher3/taskbar/customization/TaskbarAllAppsButtonContainer.kt
+++ b/quickstep/src/com/android/launcher3/taskbar/customization/TaskbarAllAppsButtonContainer.kt
@@ -32,12 +32,12 @@
 import com.android.launcher3.config.FeatureFlags.enableTaskbarPinning
 import com.android.launcher3.taskbar.TaskbarActivityContext
 import com.android.launcher3.taskbar.TaskbarViewCallbacks
-import com.android.launcher3.util.DisplayController
 import com.android.launcher3.util.Executors.MAIN_EXECUTOR
 import com.android.launcher3.views.ActivityContext
 import com.android.launcher3.views.IconButtonView
 import com.android.quickstep.DeviceConfigWrapper
 import com.android.quickstep.util.ContextualSearchStateManager
+import com.android.wm.shell.Flags
 
 /** Taskbar all apps button container for customizable taskbar. */
 class TaskbarAllAppsButtonContainer
@@ -69,7 +69,7 @@
             )
         backgroundTintList = ColorStateList.valueOf(TRANSPARENT)
         setIconDrawable(drawable)
-        if (!DisplayController.isTransientTaskbar(context)) {
+        if (!activityContext.isTransientTaskbar) {
             setPadding(dpToPx(activityContext.taskbarSpecsEvaluator.taskbarIconPadding.toFloat()))
         }
         setForegroundTint(activityContext.getColor(R.color.all_apps_button_color))
@@ -98,14 +98,34 @@
 
     @DrawableRes
     private fun getAllAppsButton(isTransientTaskbar: Boolean): Int {
+        if (Flags.enableGsf()) {
+            return getAllAppsButtonForExpressiveTheme()
+        }
         val shouldSelectTransientIcon =
             isTransientTaskbar || (enableTaskbarPinning() && !activityContext.isThreeButtonNav)
         return if (shouldSelectTransientIcon) R.drawable.ic_transient_taskbar_all_apps_search_button
         else R.drawable.ic_taskbar_all_apps_search_button
     }
 
+    @DrawableRes
+    private fun getAllAppsButtonForExpressiveTheme(): Int {
+        return R.drawable.ic_taskbar_all_apps_search_button_expressive_theme
+    }
+
+    @DimenRes
+    fun getAllAppsButtonTranslationXOffsetForExpressiveTheme(isTransientTaskbar: Boolean): Int {
+        return if (isTransientTaskbar) {
+            R.dimen.transient_taskbar_all_apps_button_translation_x_offset_for_expressive_theme
+        } else {
+            R.dimen.taskbar_all_apps_search_button_translation_x_offset_for_expressive_theme
+        }
+    }
+
     @DimenRes
     fun getAllAppsButtonTranslationXOffset(isTransientTaskbar: Boolean): Int {
+        if (Flags.enableGsf()) {
+            return getAllAppsButtonTranslationXOffsetForExpressiveTheme(isTransientTaskbar)
+        }
         return if (isTransientTaskbar) {
             R.dimen.transient_taskbar_all_apps_button_translation_x_offset
         } else {
diff --git a/quickstep/src/com/android/launcher3/taskbar/customization/TaskbarDividerContainer.kt b/quickstep/src/com/android/launcher3/taskbar/customization/TaskbarDividerContainer.kt
index d5f72d5..08a1b48 100644
--- a/quickstep/src/com/android/launcher3/taskbar/customization/TaskbarDividerContainer.kt
+++ b/quickstep/src/com/android/launcher3/taskbar/customization/TaskbarDividerContainer.kt
@@ -20,15 +20,16 @@
 import android.content.Context
 import android.content.res.ColorStateList
 import android.graphics.Color.TRANSPARENT
+import android.graphics.drawable.Drawable
 import android.util.AttributeSet
 import androidx.core.view.setPadding
 import com.android.launcher3.R
 import com.android.launcher3.Utilities.dpToPx
 import com.android.launcher3.taskbar.TaskbarActivityContext
 import com.android.launcher3.taskbar.TaskbarViewCallbacks
-import com.android.launcher3.util.DisplayController
 import com.android.launcher3.views.ActivityContext
 import com.android.launcher3.views.IconButtonView
+import com.android.wm.shell.Flags
 
 /** Taskbar divider view container for customizable taskbar. */
 class TaskbarDividerContainer
@@ -47,16 +48,24 @@
         setUpIcon()
     }
 
-    @SuppressLint("UseCompatLoadingForDrawables")
     fun setUpIcon() {
         backgroundTintList = ColorStateList.valueOf(TRANSPARENT)
-        val drawable = resources.getDrawable(R.drawable.taskbar_divider_button)
+        val drawable = getTaskbarDividerIcon()
         setIconDrawable(drawable)
-        if (!DisplayController.isTransientTaskbar(context)) {
+        if (!activityContext.isTransientTaskbar) {
             setPadding(dpToPx(activityContext.taskbarSpecsEvaluator.taskbarIconPadding.toFloat()))
         }
     }
 
+    @SuppressLint("UseCompatLoadingForDrawables")
+    fun getTaskbarDividerIcon(): Drawable {
+        return if (Flags.enableGsf()) {
+            resources.getDrawable(R.drawable.taskbar_divider_button_expressive_theme)
+        } else {
+            resources.getDrawable(R.drawable.taskbar_divider_button)
+        }
+    }
+
     @SuppressLint("ClickableViewAccessibility")
     fun setUpCallbacks(callbacks: TaskbarViewCallbacks) {
         setOnLongClickListener(callbacks.taskbarDividerLongClickListener)
diff --git a/quickstep/src/com/android/launcher3/taskbar/customization/TaskbarFeatureEvaluator.kt b/quickstep/src/com/android/launcher3/taskbar/customization/TaskbarFeatureEvaluator.kt
index f130d29..a14c5a4 100644
--- a/quickstep/src/com/android/launcher3/taskbar/customization/TaskbarFeatureEvaluator.kt
+++ b/quickstep/src/com/android/launcher3/taskbar/customization/TaskbarFeatureEvaluator.kt
@@ -19,7 +19,6 @@
 import com.android.launcher3.Flags.enableRecentsInTaskbar
 import com.android.launcher3.config.FeatureFlags.enableTaskbarPinning
 import com.android.launcher3.taskbar.TaskbarActivityContext
-import com.android.launcher3.util.DisplayController
 
 /** Evaluates all the features taskbar can have. */
 class TaskbarFeatureEvaluator
@@ -36,7 +35,7 @@
         get() = enableTaskbarPinning() || isRecentsEnabled
 
     val isTransient: Boolean
-        get() = DisplayController.isTransientTaskbar(taskbarActivityContext)
+        get() = taskbarActivityContext.isTransientTaskbar
 
     val isLandscape: Boolean
         get() = taskbarActivityContext.deviceProfile.isLandscape
diff --git a/quickstep/src/com/android/launcher3/taskbar/growth/GrowthConstants.java b/quickstep/src/com/android/launcher3/taskbar/growth/GrowthConstants.java
index 78ef152..7d760fc 100644
--- a/quickstep/src/com/android/launcher3/taskbar/growth/GrowthConstants.java
+++ b/quickstep/src/com/android/launcher3/taskbar/growth/GrowthConstants.java
@@ -24,5 +24,13 @@
      */
     public static final String BROADCAST_SHOW_NUDGE =
             "com.android.launcher3.growth.BROADCAST_SHOW_NUDGE";
+
+    /**
+     * For filtering package of broadcast intent received.
+     */
+    public static final String GROWTH_NUDGE_PERMISSION =
+            "com.android.growth.permission.GROWTH_NUDGE_PERMISSION"
+                    + " android:protectionLevel=\"signature|preinstalled\"";
+
     private GrowthConstants() {}
 }
diff --git a/quickstep/src/com/android/launcher3/taskbar/growth/NudgeController.kt b/quickstep/src/com/android/launcher3/taskbar/growth/NudgeController.kt
new file mode 100644
index 0000000..04e41bc
--- /dev/null
+++ b/quickstep/src/com/android/launcher3/taskbar/growth/NudgeController.kt
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.launcher3.taskbar.growth
+
+import android.content.Context
+import com.android.launcher3.Utilities
+import com.android.launcher3.taskbar.TaskbarActivityContext
+import com.android.launcher3.taskbar.TaskbarControllers
+import com.android.launcher3.taskbar.TaskbarControllers.LoggableTaskbarController
+import com.android.launcher3.util.DisplayController
+import com.android.launcher3.views.ActivityContext
+import java.io.PrintWriter
+
+/** Controls nudge lifecycles. */
+class NudgeController(context: Context) : LoggableTaskbarController {
+
+    protected val activityContext: TaskbarActivityContext = ActivityContext.lookupContext(context)
+
+    private val isNudgeEnabled: Boolean
+        get() {
+            return !Utilities.isRunningInTestHarness() &&
+                !activityContext.isPhoneMode &&
+                !activityContext.isTinyTaskbar
+        }
+
+    private lateinit var controllers: TaskbarControllers
+
+    fun init(controllers: TaskbarControllers) {
+        this.controllers = controllers
+    }
+
+    fun maybeShow(payload: NudgePayload) {
+        if (!isNudgeEnabled || !DisplayController.isTransientTaskbar(activityContext)) {
+            return
+        }
+        // TODO: b/398033012 - create and show nudge view based on the payload.
+    }
+
+    /** Closes the current [nudgeView]. */
+    fun hide() {
+        // TODO: b/398033012 - hide the nudge view.
+    }
+
+    override fun dumpLogs(prefix: String?, pw: PrintWriter?) {
+        pw?.println(prefix + "NudgeController:")
+        pw?.println("$prefix\tisNudgeEnabled=$isNudgeEnabled")
+    }
+}
diff --git a/quickstep/src/com/android/launcher3/taskbar/navbutton/NearestTouchFrame.java b/quickstep/src/com/android/launcher3/taskbar/navbutton/NearestTouchFrame.java
index bbf08bf..844f1af 100644
--- a/quickstep/src/com/android/launcher3/taskbar/navbutton/NearestTouchFrame.java
+++ b/quickstep/src/com/android/launcher3/taskbar/navbutton/NearestTouchFrame.java
@@ -194,6 +194,7 @@
                 event.offsetLocation(mTouchingChild.getWidth() / 2 - x,
                         mTouchingChild.getHeight() / 2 - y);
                 return mTouchingChild.getVisibility() == VISIBLE
+                        && mTouchingChild.isAttachedToWindow()
                         && mTouchingChild.dispatchTouchEvent(event);
             }
         }
diff --git a/quickstep/src/com/android/launcher3/taskbar/overlay/TaskbarOverlayContext.java b/quickstep/src/com/android/launcher3/taskbar/overlay/TaskbarOverlayContext.java
index 55bb0f9..8574b89 100644
--- a/quickstep/src/com/android/launcher3/taskbar/overlay/TaskbarOverlayContext.java
+++ b/quickstep/src/com/android/launcher3/taskbar/overlay/TaskbarOverlayContext.java
@@ -31,6 +31,7 @@
 import com.android.launcher3.taskbar.TaskbarUIController;
 import com.android.launcher3.taskbar.allapps.TaskbarAllAppsContainerView;
 import com.android.launcher3.taskbar.allapps.TaskbarSearchSessionController;
+import com.android.launcher3.util.NavigationMode;
 import com.android.launcher3.util.SplitConfigurationOptions.SplitSelectSource;
 
 /**
@@ -55,7 +56,7 @@
             Context windowContext,
             TaskbarActivityContext taskbarContext,
             TaskbarControllers controllers) {
-        super(windowContext);
+        super(windowContext, taskbarContext.isPrimaryDisplay());
         mTaskbarContext = taskbarContext;
         mOverlayController = controllers.taskbarOverlayController;
         mDragController = new TaskbarDragController(this);
@@ -67,6 +68,11 @@
         onViewCreated();
     }
 
+    /** Called when the controller is destroyed. */
+    public void onDestroy() {
+        mDragController.onDestroy();
+    }
+
     public @Nullable TaskbarSearchSessionController getSearchSessionController() {
         return mSearchSessionController;
     }
@@ -137,6 +143,41 @@
     }
 
     @Override
+    public boolean isTransientTaskbar() {
+        return mTaskbarContext.isTransientTaskbar();
+    }
+
+    @Override
+    public boolean isPinnedTaskbar() {
+        return mTaskbarContext.isPinnedTaskbar();
+    }
+
+    @Override
+    public NavigationMode getNavigationMode() {
+        return mTaskbarContext.getNavigationMode();
+    }
+
+    @Override
+    public boolean isInDesktopMode() {
+        return mTaskbarContext.isInDesktopMode();
+    }
+
+    @Override
+    public boolean showLockedTaskbarOnHome() {
+        return mTaskbarContext.showLockedTaskbarOnHome();
+    }
+
+    @Override
+    public boolean showDesktopTaskbarForFreeformDisplay() {
+        return mTaskbarContext.showDesktopTaskbarForFreeformDisplay();
+    }
+
+    @Override
+    public boolean isPrimaryDisplay() {
+        return mTaskbarContext.isPrimaryDisplay();
+    }
+
+    @Override
     public void onDragStart() {}
 
     @Override
diff --git a/quickstep/src/com/android/launcher3/taskbar/overlay/TaskbarOverlayController.java b/quickstep/src/com/android/launcher3/taskbar/overlay/TaskbarOverlayController.java
index 79cb748..de20f77 100644
--- a/quickstep/src/com/android/launcher3/taskbar/overlay/TaskbarOverlayController.java
+++ b/quickstep/src/com/android/launcher3/taskbar/overlay/TaskbarOverlayController.java
@@ -26,8 +26,12 @@
 import android.annotation.SuppressLint;
 import android.content.Context;
 import android.graphics.PixelFormat;
+import android.util.Log;
+import android.view.AttachedSurfaceControl;
 import android.view.Gravity;
 import android.view.MotionEvent;
+import android.view.SurfaceControl;
+import android.view.ViewRootImpl;
 import android.view.WindowManager;
 import android.view.WindowManager.LayoutParams;
 
@@ -36,8 +40,10 @@
 import com.android.launcher3.AbstractFloatingView;
 import com.android.launcher3.DeviceProfile;
 import com.android.launcher3.Flags;
+import com.android.launcher3.R;
 import com.android.launcher3.taskbar.TaskbarActivityContext;
 import com.android.launcher3.taskbar.TaskbarControllers;
+import com.android.systemui.shared.system.BlurUtils;
 import com.android.systemui.shared.system.TaskStackChangeListener;
 import com.android.systemui.shared.system.TaskStackChangeListeners;
 
@@ -52,12 +58,14 @@
  */
 public final class TaskbarOverlayController {
 
+    private static final String TAG = "TaskbarOverlayController";
     private static final String WINDOW_TITLE = "Taskbar Overlay";
 
     private final TaskbarActivityContext mTaskbarContext;
     private final Context mWindowContext;
     private final TaskbarOverlayProxyView mProxyView;
     private final LayoutParams mLayoutParams;
+    private final int mMaxBlurRadius;
 
     private final TaskStackChangeListener mTaskStackListener = new TaskStackChangeListener() {
         @Override
@@ -88,6 +96,8 @@
     private DeviceProfile mLauncherDeviceProfile;
     private @Nullable TaskbarOverlayContext mOverlayContext;
     private TaskbarControllers mControllers; // Initialized in init.
+    // True if we have alerted surface flinger of an expensive call for blur.
+    private boolean mInEarlyWakeUp;
 
     public TaskbarOverlayController(
             TaskbarActivityContext taskbarContext, DeviceProfile launcherDeviceProfile) {
@@ -96,6 +106,8 @@
         mProxyView = new TaskbarOverlayProxyView();
         mLayoutParams = createLayoutParams();
         mLauncherDeviceProfile = launcherDeviceProfile;
+        mMaxBlurRadius = mTaskbarContext.getResources().getDimensionPixelSize(
+                R.dimen.max_depth_blur_radius_enhanced);
     }
 
     /** Initialize the controller. */
@@ -150,9 +162,13 @@
     /** Destroys the controller and any overlay window if present. */
     public void onDestroy() {
         TaskStackChangeListeners.getInstance().unregisterTaskStackListener(mTaskStackListener);
-        Optional.ofNullable(mOverlayContext)
-                .map(c -> c.getSystemService(WindowManager.class))
-                .ifPresent(m -> m.removeViewImmediate(mOverlayContext.getDragLayer()));
+        Optional.ofNullable(mOverlayContext).ifPresent(c -> {
+            c.onDestroy();
+            WindowManager wm = c.getSystemService(WindowManager.class);
+            if (wm != null) {
+                wm.removeViewImmediate(mOverlayContext.getDragLayer());
+            }
+        });
         mOverlayContext = null;
     }
 
@@ -184,7 +200,7 @@
     private LayoutParams createLayoutParams() {
         LayoutParams layoutParams = new LayoutParams(
                 TYPE_APPLICATION_OVERLAY,
-                LayoutParams.FLAG_SPLIT_TOUCH,
+                /* flags = */ 0,
                 PixelFormat.TRANSLUCENT);
         layoutParams.setTitle(WINDOW_TITLE);
         layoutParams.gravity = Gravity.BOTTOM;
@@ -197,6 +213,65 @@
     }
 
     /**
+     * Sets the blur radius for the overlay window.
+     *
+     * @param radius the blur radius in pixels. This will automatically change to {@code 0} if blurs
+     *               are unsupported on the device.
+     */
+    public void setBackgroundBlurRadius(int radius) {
+        if (!Flags.allAppsBlur()) {
+            return;
+        }
+        if (!BlurUtils.supportsBlursOnWindows()) {
+            Log.d(TAG, "setBackgroundBlurRadius: not supported, setting to 0");
+            radius = 0;
+            // intentionally falling through in case a non-0 blur was previously set.
+        }
+        if (mOverlayContext == null) {
+            Log.w(TAG, "setBackgroundBlurRadius: no overlay context");
+            return;
+        }
+        TaskbarOverlayDragLayer dragLayer = mOverlayContext.getDragLayer();
+        if (dragLayer == null) {
+            Log.w(TAG, "setBackgroundBlurRadius: no drag layer");
+            return;
+        }
+        ViewRootImpl dragLayerViewRoot = dragLayer.getViewRootImpl();
+        if (dragLayerViewRoot == null) {
+            Log.w(TAG, "setBackgroundBlurRadius: dragLayerViewRoot is null");
+            return;
+        }
+        AttachedSurfaceControl rootSurfaceControl = dragLayer.getRootSurfaceControl();
+        if (rootSurfaceControl == null) {
+            Log.w(TAG, "setBackgroundBlurRadius: rootSurfaceControl is null");
+            return;
+        }
+        SurfaceControl surfaceControl = dragLayerViewRoot.getSurfaceControl();
+        if (surfaceControl == null || !surfaceControl.isValid()) {
+            Log.w(TAG, "setBackgroundBlurRadius: surfaceControl is null or invalid");
+            return;
+        }
+        Log.v(TAG, "setBackgroundBlurRadius: " + radius);
+        SurfaceControl.Transaction transaction =
+                new SurfaceControl.Transaction().setBackgroundBlurRadius(surfaceControl, radius);
+
+        // Set early wake-up flags when we know we're executing an expensive operation, this way
+        // SurfaceFlinger will adjust its internal offsets to avoid jank.
+        boolean wantsEarlyWakeUp = radius > 0 && radius < mMaxBlurRadius;
+        if (wantsEarlyWakeUp && !mInEarlyWakeUp) {
+            Log.d(TAG, "setBackgroundBlurRadius: setting early wakeup");
+            transaction.setEarlyWakeupStart();
+            mInEarlyWakeUp = true;
+        } else if (!wantsEarlyWakeUp && mInEarlyWakeUp) {
+            Log.d(TAG, "setBackgroundBlurRadius: clearing early wakeup");
+            transaction.setEarlyWakeupEnd();
+            mInEarlyWakeUp = false;
+        }
+
+        rootSurfaceControl.applyTransactionOnDraw(transaction);
+    }
+
+    /**
      * Proxy view connecting taskbar drag layer to the overlay window.
      *
      * Overlays are in a separate window and has its own drag layer, but this proxy lets its views
diff --git a/quickstep/src/com/android/launcher3/taskbar/overlay/TaskbarOverlayDragLayer.java b/quickstep/src/com/android/launcher3/taskbar/overlay/TaskbarOverlayDragLayer.java
index 669850c..41694ec 100644
--- a/quickstep/src/com/android/launcher3/taskbar/overlay/TaskbarOverlayDragLayer.java
+++ b/quickstep/src/com/android/launcher3/taskbar/overlay/TaskbarOverlayDragLayer.java
@@ -34,7 +34,6 @@
 import com.android.launcher3.AbstractFloatingView;
 import com.android.launcher3.testing.TestLogging;
 import com.android.launcher3.testing.shared.TestProtocol;
-import com.android.launcher3.util.DisplayController;
 import com.android.launcher3.util.TouchController;
 import com.android.launcher3.views.BaseDragLayer;
 
@@ -147,7 +146,7 @@
      * 2) Sets tappableInsets bottom inset to 0.
      */
     private WindowInsets updateInsetsDueToStashing(WindowInsets oldInsets) {
-        if (!DisplayController.isTransientTaskbar(mContainer)) {
+        if (!mContainer.isTransientTaskbar()) {
             return oldInsets;
         }
         WindowInsets.Builder updatedInsetsBuilder = new WindowInsets.Builder(oldInsets);
diff --git a/quickstep/src/com/android/launcher3/uioverrides/PredictedAppIcon.java b/quickstep/src/com/android/launcher3/uioverrides/PredictedAppIcon.java
index 15a27d1..e8de0d2 100644
--- a/quickstep/src/com/android/launcher3/uioverrides/PredictedAppIcon.java
+++ b/quickstep/src/com/android/launcher3/uioverrides/PredictedAppIcon.java
@@ -402,16 +402,16 @@
             canvas.scale(
                     mRingScale * (1f - RING_EFFECT_RATIO),
                     mRingScale * (1f - RING_EFFECT_RATIO),
-                    canvas.getWidth() / 2f,
-                    canvas.getHeight() / 2f);
+                    getWidth() / 2f,
+                    getHeight() / 2f);
         } else if (Float.compare(1, mRingScale) != 0) {
-            canvas.scale(mRingScale, mRingScale, canvas.getWidth() / 2f, canvas.getHeight() / 2f);
+            canvas.scale(mRingScale, mRingScale, getWidth() / 2f, getHeight() / 2f);
         }
         // Draw ring shadow around canvas.
         canvas.drawPath(mRingPath, mIconRingPaint);
         mIconRingPaint.setColor(mPlateColor.currentColor);
         if (Flags.enableLauncherIconShapes()) {
-            mIconRingPaint.setStrokeWidth(canvas.getWidth() * RING_EFFECT_RATIO);
+            mIconRingPaint.setStrokeWidth(getWidth() * RING_EFFECT_RATIO);
             // Using FILL_AND_STROKE as there is still some gap to fill,
             // between inner curve of ring / outer curve of icon.
             mIconRingPaint.setStyle(Paint.Style.FILL_AND_STROKE);
diff --git a/quickstep/src/com/android/launcher3/uioverrides/QuickstepAppWidgetHost.java b/quickstep/src/com/android/launcher3/uioverrides/QuickstepAppWidgetHost.java
deleted file mode 100644
index 45813ce..0000000
--- a/quickstep/src/com/android/launcher3/uioverrides/QuickstepAppWidgetHost.java
+++ /dev/null
@@ -1,74 +0,0 @@
-/**
- * Copyright (C) 2022 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.android.launcher3.uioverrides;
-
-import static com.android.launcher3.widget.LauncherWidgetHolder.APPWIDGET_HOST_ID;
-
-import android.appwidget.AppWidgetHost;
-import android.appwidget.AppWidgetProviderInfo;
-import android.content.Context;
-import android.os.Looper;
-
-import androidx.annotation.NonNull;
-
-import com.android.launcher3.LauncherAppState;
-import com.android.launcher3.util.Executors;
-import com.android.launcher3.widget.LauncherAppWidgetProviderInfo;
-import com.android.launcher3.widget.LauncherWidgetHolder;
-
-import java.util.function.IntConsumer;
-
-/**
- * {@link AppWidgetHost} that is used to receive the changes to the widgets without
- * storing any {@code Activity} info like that of the launcher.
- */
-final class QuickstepAppWidgetHost extends AppWidgetHost {
-    private final @NonNull Context mContext;
-    private final @NonNull IntConsumer mAppWidgetRemovedCallback;
-    private final @NonNull LauncherWidgetHolder.ProviderChangedListener mProvidersChangedListener;
-
-    QuickstepAppWidgetHost(@NonNull Context context, @NonNull IntConsumer appWidgetRemovedCallback,
-            @NonNull LauncherWidgetHolder.ProviderChangedListener listener,
-            @NonNull Looper looper) {
-        super(context, APPWIDGET_HOST_ID, null, looper);
-        mContext = context;
-        mAppWidgetRemovedCallback = appWidgetRemovedCallback;
-        mProvidersChangedListener = listener;
-    }
-
-    @Override
-    protected void onProvidersChanged() {
-        mProvidersChangedListener.notifyWidgetProvidersChanged();
-    }
-
-    @Override
-    public void onAppWidgetRemoved(int appWidgetId) {
-        // Route the call via model thread, in case it comes while a loader-bind is in progress
-        Executors.MODEL_EXECUTOR.execute(
-                () -> Executors.MAIN_EXECUTOR.execute(
-                        () -> mAppWidgetRemovedCallback.accept(appWidgetId)));
-    }
-
-    @Override
-    protected void onProviderChanged(int appWidgetId, @NonNull AppWidgetProviderInfo appWidget) {
-        LauncherAppWidgetProviderInfo info = LauncherAppWidgetProviderInfo.fromProviderInfo(
-                mContext, appWidget);
-        super.onProviderChanged(appWidgetId, info);
-        // The super method updates the dimensions of the providerInfo. Update the
-        // launcher spans accordingly.
-        info.initSpans(mContext, LauncherAppState.getIDP(mContext));
-    }
-}
diff --git a/quickstep/src/com/android/launcher3/uioverrides/QuickstepAppWidgetHostProvider.kt b/quickstep/src/com/android/launcher3/uioverrides/QuickstepAppWidgetHostProvider.kt
new file mode 100644
index 0000000..1387cb7
--- /dev/null
+++ b/quickstep/src/com/android/launcher3/uioverrides/QuickstepAppWidgetHostProvider.kt
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.launcher3.uioverrides
+
+import android.app.ActivityThread
+import android.content.Context
+import android.content.ContextWrapper
+import com.android.launcher3.BuildConfig
+import com.android.launcher3.util.LooperExecutor
+import com.android.launcher3.widget.LauncherWidgetHolder
+import com.android.launcher3.widget.ListenableAppWidgetHost
+
+object QuickstepAppWidgetHostProvider {
+
+    /** Static widget host which is always listening and is lazily created */
+    @JvmStatic
+    val staticQuickstepHost: ListenableAppWidgetHost by lazy {
+        ListenableAppWidgetHost(
+                LooperContext(
+                    ActivityThread.currentApplication(),
+                    ListenableAppWidgetHost.widgetHolderExecutor,
+                ),
+                LauncherWidgetHolder.APPWIDGET_HOST_ID,
+            )
+            .apply { if (BuildConfig.WIDGETS_ENABLED) startListening() }
+    }
+
+    private class LooperContext(ctx: Context, val executor: LooperExecutor) : ContextWrapper(ctx) {
+
+        override fun getMainLooper() = executor.looper
+
+        override fun getMainExecutor() = executor
+    }
+}
diff --git a/quickstep/src/com/android/launcher3/uioverrides/QuickstepInteractionHandler.java b/quickstep/src/com/android/launcher3/uioverrides/QuickstepInteractionHandler.java
index 26a1322..2f61eab 100644
--- a/quickstep/src/com/android/launcher3/uioverrides/QuickstepInteractionHandler.java
+++ b/quickstep/src/com/android/launcher3/uioverrides/QuickstepInteractionHandler.java
@@ -34,8 +34,11 @@
 import com.android.launcher3.util.ActivityOptionsWrapper;
 import com.android.launcher3.widget.LauncherAppWidgetHostView;
 
+import java.util.function.Consumer;
+
 /** Provides a Quickstep specific animation when launching an activity from an app widget. */
-class QuickstepInteractionHandler implements RemoteViews.InteractionHandler {
+class QuickstepInteractionHandler implements RemoteViews.InteractionHandler,
+        Consumer<LauncherAppWidgetHostView> {
 
     private static final String TAG = "QuickstepInteractionHandler";
 
@@ -45,6 +48,11 @@
         mLauncher = launcher;
     }
 
+    @Override
+    public void accept(LauncherAppWidgetHostView host) {
+        host.setInteractionHandler(this);
+    }
+
     @SuppressWarnings("NewApi")
     @Override
     public boolean onInteraction(View view, PendingIntent pendingIntent,
diff --git a/quickstep/src/com/android/launcher3/uioverrides/QuickstepLauncher.java b/quickstep/src/com/android/launcher3/uioverrides/QuickstepLauncher.java
index cd0a4f3..605fd31 100644
--- a/quickstep/src/com/android/launcher3/uioverrides/QuickstepLauncher.java
+++ b/quickstep/src/com/android/launcher3/uioverrides/QuickstepLauncher.java
@@ -86,6 +86,7 @@
 import android.os.UserHandle;
 import android.text.TextUtils;
 import android.util.AttributeSet;
+import android.util.Log;
 import android.view.Display;
 import android.view.HapticFeedbackConstants;
 import android.view.KeyEvent;
@@ -142,7 +143,6 @@
 import com.android.launcher3.taskbar.TaskbarUIController;
 import com.android.launcher3.testing.TestLogging;
 import com.android.launcher3.testing.shared.TestProtocol;
-import com.android.launcher3.uioverrides.QuickstepWidgetHolder.QuickstepHolderFactory;
 import com.android.launcher3.uioverrides.states.QuickstepAtomicAnimationFactory;
 import com.android.launcher3.uioverrides.touchcontrollers.NavBarToHomeTouchController;
 import com.android.launcher3.uioverrides.touchcontrollers.NoButtonNavbarToOverviewTouchController;
@@ -171,7 +171,6 @@
 import com.android.launcher3.util.StartActivityParams;
 import com.android.launcher3.util.TouchController;
 import com.android.launcher3.views.FloatingIconView;
-import com.android.launcher3.widget.LauncherWidgetHolder;
 import com.android.quickstep.OverviewCommandHelper;
 import com.android.quickstep.OverviewComponentObserver;
 import com.android.quickstep.OverviewComponentObserver.OverviewChangeListener;
@@ -226,6 +225,7 @@
 
 public class QuickstepLauncher extends Launcher implements RecentsViewContainer,
         SystemShortcut.BubbleActivityStarter {
+    private static final String TAG = "QuickstepLauncher";
     private static final boolean TRACE_LAYOUTS =
             SystemProperties.getBoolean("persist.debug.trace_layouts", false);
     private static final String TRACE_RELAYOUT_CLASS =
@@ -296,6 +296,7 @@
 
     @Override
     protected void setupViews() {
+        getAppWidgetHolder().setOnViewCreationCallback(new QuickstepInteractionHandler(this));
         super.setupViews();
 
         mActionsView = findViewById(R.id.overview_actions_view);
@@ -561,20 +562,35 @@
 
     @Override
     public void onDestroy() {
+        // wrap non-trivial clean up blocks in try-catch to avoid stopping clean up of rest of
+        // objects
+
         if (mAppTransitionManager != null) {
-            mAppTransitionManager.onActivityDestroyed();
+            try {
+                mAppTransitionManager.onActivityDestroyed();
+            } catch (Exception e) {
+                Log.e(TAG, "Failed to destroy mAppTransitionManager", e);
+            }
         }
         mAppTransitionManager = null;
         mIsPredictiveBackToHomeInProgress = false;
 
         if (mUnfoldTransitionProgressProvider != null) {
-            SystemUiProxy.INSTANCE.get(this).setUnfoldAnimationListener(null);
-            mUnfoldTransitionProgressProvider.destroy();
+            try {
+                SystemUiProxy.INSTANCE.get(this).setUnfoldAnimationListener(null);
+                mUnfoldTransitionProgressProvider.destroy();
+            } catch (Exception e) {
+                Log.e(TAG, "Failed to destroy mUnfoldTransitionProgressProvider", e);
+            }
         }
 
         OverviewComponentObserver.INSTANCE.get(this)
                 .removeOverviewChangeListener(mOverviewChangeListener);
-        mTISBindHelper.onDestroy();
+        try {
+            mTISBindHelper.onDestroy();
+        } catch (Exception e) {
+            Log.e(TAG, "Failed to destroy mTISBindHelper", e);
+        }
 
         if (mLauncherUnfoldAnimationController != null) {
             mLauncherUnfoldAnimationController.onDestroy();
@@ -584,15 +600,22 @@
             mSplitSelectStateController.onDestroy();
         }
 
-        RecentsView recentsView = getOverviewPanel();
-        if (recentsView != null) {
-            recentsView.destroy();
+        try {
+            RecentsView recentsView = getOverviewPanel();
+            if (recentsView != null) {
+                recentsView.destroy();
+            }
+        } catch (Exception e) {
+            Log.e(TAG, "Failed to destroy RecentsView", e);
         }
 
-        super.onDestroy();
-        mHotseatPredictionController.destroy();
-        if (mViewCapture != null) mViewCapture.close();
-        removeBackAnimationCallback(mSplitSelectStateController.getSplitBackHandler());
+        try {
+            super.onDestroy();
+        } finally { // trivial close operations in finally.
+            mHotseatPredictionController.destroy();
+            if (mViewCapture != null) mViewCapture.close();
+            removeBackAnimationCallback(mSplitSelectStateController.getSplitBackHandler());
+        }
     }
 
     @Override
@@ -702,15 +725,6 @@
     }
 
     @Override
-    protected LauncherWidgetHolder createAppWidgetHolder() {
-        final QuickstepHolderFactory factory =
-                (QuickstepHolderFactory) LauncherWidgetHolder.HolderFactory.newFactory(this);
-        return factory.newInstance(this,
-                appWidgetId -> getWorkspace().removeWidget(appWidgetId),
-                new QuickstepInteractionHandler(this));
-    }
-
-    @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         if (savedInstanceState != null) {
diff --git a/quickstep/src/com/android/launcher3/uioverrides/QuickstepWidgetHolder.java b/quickstep/src/com/android/launcher3/uioverrides/QuickstepWidgetHolder.java
index 56fc4d1..9970a7d 100644
--- a/quickstep/src/com/android/launcher3/uioverrides/QuickstepWidgetHolder.java
+++ b/quickstep/src/com/android/launcher3/uioverrides/QuickstepWidgetHolder.java
@@ -16,13 +16,14 @@
 package com.android.launcher3.uioverrides;
 
 import static com.android.launcher3.BuildConfig.WIDGETS_ENABLED;
+import static com.android.launcher3.uioverrides.QuickstepAppWidgetHostProvider.getStaticQuickstepHost;
 import static com.android.launcher3.util.Executors.MAIN_EXECUTOR;
+import static com.android.launcher3.widget.ListenableAppWidgetHost.getWidgetHolderExecutor;
 
 import android.appwidget.AppWidgetHost;
 import android.appwidget.AppWidgetHostView;
 import android.appwidget.AppWidgetProviderInfo;
 import android.content.Context;
-import android.util.Log;
 import android.util.SparseArray;
 import android.widget.RemoteViews;
 
@@ -31,28 +32,26 @@
 import androidx.annotation.Nullable;
 import androidx.annotation.UiThread;
 
-import com.android.launcher3.config.FeatureFlags;
 import com.android.launcher3.util.IntSet;
 import com.android.launcher3.util.SafeCloseable;
 import com.android.launcher3.widget.LauncherAppWidgetHostView;
 import com.android.launcher3.widget.LauncherAppWidgetProviderInfo;
 import com.android.launcher3.widget.LauncherWidgetHolder;
 
-import java.util.ArrayList;
+import dagger.assisted.Assisted;
+import dagger.assisted.AssistedFactory;
+import dagger.assisted.AssistedInject;
+
 import java.util.Collections;
-import java.util.List;
 import java.util.Set;
 import java.util.WeakHashMap;
 import java.util.function.BiConsumer;
-import java.util.function.IntConsumer;
 
 /**
  * {@link LauncherWidgetHolder} that puts the app widget host in the background
  */
 public final class QuickstepWidgetHolder extends LauncherWidgetHolder {
 
-    private static final String TAG = "QuickstepWidgetHolder";
-
     private static final UpdateKey<AppWidgetProviderInfo> KEY_PROVIDER_UPDATE =
             AppWidgetHostView::onUpdateProviderInfo;
     private static final UpdateKey<RemoteViews> KEY_VIEWS_UPDATE =
@@ -60,51 +59,17 @@
     private static final UpdateKey<Integer> KEY_VIEW_DATA_CHANGED =
             AppWidgetHostView::onViewDataChanged;
 
-    private static final List<QuickstepWidgetHolder> sHolders = new ArrayList<>();
     private static final SparseArray<QuickstepWidgetHolderListener> sListeners =
             new SparseArray<>();
 
-    private static AppWidgetHost sWidgetHost = null;
-
     private final UpdateHandler mUpdateHandler = this::onWidgetUpdate;
-    private final @Nullable RemoteViews.InteractionHandler mInteractionHandler;
-
-    private final @NonNull IntConsumer mAppWidgetRemovedCallback;
 
     // Map to all pending updated keyed with appWidgetId;
     private final SparseArray<PendingUpdate> mPendingUpdateMap = new SparseArray<>();
 
-    private QuickstepWidgetHolder(@NonNull Context context,
-            @Nullable IntConsumer appWidgetRemovedCallback,
-            @Nullable RemoteViews.InteractionHandler interactionHandler) {
-        super(context, appWidgetRemovedCallback);
-        mAppWidgetRemovedCallback = appWidgetRemovedCallback != null ? appWidgetRemovedCallback
-                : i -> {};
-        mInteractionHandler = interactionHandler;
-        MAIN_EXECUTOR.execute(() -> sHolders.add(this));
-    }
-
-    @Override
-    @NonNull
-    protected AppWidgetHost createHost(@NonNull Context context,
-            @Nullable IntConsumer appWidgetRemovedCallback) {
-        if (sWidgetHost == null) {
-            sWidgetHost = new QuickstepAppWidgetHost(context.getApplicationContext(),
-                    i -> MAIN_EXECUTOR.execute(() ->
-                            sHolders.forEach(h -> h.mAppWidgetRemovedCallback.accept(i))),
-                    () -> MAIN_EXECUTOR.execute(() ->
-                            sHolders.forEach(h ->
-                                    // Listeners might remove themselves from the list during the
-                                    // iteration. Creating a copy of the list to avoid exceptions
-                                    // for concurrent modification.
-                                    new ArrayList<>(h.mProviderChangedListeners).forEach(
-                                    ProviderChangedListener::notifyWidgetProvidersChanged))),
-                    getWidgetHolderExecutor().getLooper());
-            if (WIDGETS_ENABLED) {
-                sWidgetHost.startListening();
-            }
-        }
-        return sWidgetHost;
+    @AssistedInject
+    public QuickstepWidgetHolder(@Assisted("UI_CONTEXT") @NonNull Context context) {
+        super(context, getStaticQuickstepHost());
     }
 
     @Override
@@ -168,21 +133,6 @@
         sListeners.remove(appWidgetId);
     }
 
-    /**
-     * Called when the launcher is destroyed
-     */
-    @Override
-    public void destroy() {
-        try {
-            MAIN_EXECUTOR.submit(() -> {
-                clearViews();
-                sHolders.remove(this);
-            }).get();
-        } catch (Exception e) {
-            Log.e(TAG, "Failed to remove self from holder list", e);
-        }
-    }
-
     @Override
     protected boolean shouldListen(int flags) {
         return (flags & (FLAG_STATE_IS_NORMAL | FLAG_ACTIVITY_STARTED))
@@ -199,7 +149,7 @@
         }
 
         getWidgetHolderExecutor().execute(() -> {
-            sWidgetHost.setAppWidgetHidden();
+            mWidgetHost.setAppWidgetHidden();
             setListeningFlag(false);
         });
     }
@@ -239,7 +189,6 @@
     protected LauncherAppWidgetHostView createViewInternal(
             int appWidgetId, @NonNull LauncherAppWidgetProviderInfo appWidget) {
         LauncherAppWidgetHostView widgetView = new LauncherAppWidgetHostView(mContext);
-        widgetView.setInteractionHandler(mInteractionHandler);
         widgetView.setAppWidget(appWidgetId, appWidget);
         widgetView.updateAppWidget(getHolderListener(appWidgetId).addHolder(mUpdateHandler));
         return widgetView;
@@ -249,7 +198,7 @@
         QuickstepWidgetHolderListener listener = sListeners.get(appWidgetId);
         if (listener == null) {
             listener = new QuickstepWidgetHolderListener(appWidgetId);
-            sWidgetHost.setListener(appWidgetId, listener);
+            getStaticQuickstepHost().setListener(appWidgetId, listener);
             sListeners.put(appWidgetId, listener);
         }
         return listener;
@@ -322,44 +271,13 @@
         }
     }
 
-    /**
-     * {@code HolderFactory} subclass that takes an interaction handler as one of the parameters
-     * when creating a new instance.
-     */
-    public static class QuickstepHolderFactory extends HolderFactory {
 
-        @SuppressWarnings("unused")
-        public QuickstepHolderFactory(Context context) { }
+    /** A factory that generates new instances of {@code LauncherWidgetHolder} */
+    @AssistedFactory
+    public interface QuickstepWidgetHolderFactory extends WidgetHolderFactory {
 
         @Override
-        public LauncherWidgetHolder newInstance(@NonNull Context context,
-                @Nullable IntConsumer appWidgetRemovedCallback) {
-            return newInstance(context, appWidgetRemovedCallback, null);
-        }
-
-        /**
-         * @param context The context of the caller
-         * @param appWidgetRemovedCallback The callback that is called when widgets are removed
-         * @param interactionHandler The interaction handler when the widgets are clicked
-         * @return A new {@link LauncherWidgetHolder} instance
-         */
-        public LauncherWidgetHolder newInstance(@NonNull Context context,
-                @Nullable IntConsumer appWidgetRemovedCallback,
-                @Nullable RemoteViews.InteractionHandler interactionHandler) {
-
-            if (!FeatureFlags.ENABLE_WIDGET_HOST_IN_BACKGROUND.get()) {
-                return new LauncherWidgetHolder(context, appWidgetRemovedCallback) {
-                    @Override
-                    protected AppWidgetHost createHost(Context context,
-                            @Nullable IntConsumer appWidgetRemovedCallback) {
-                        AppWidgetHost host = super.createHost(context, appWidgetRemovedCallback);
-                        host.setInteractionHandler(interactionHandler);
-                        return host;
-                    }
-                };
-            }
-            return new QuickstepWidgetHolder(context, appWidgetRemovedCallback, interactionHandler);
-        }
+        QuickstepWidgetHolder newInstance(@Assisted("UI_CONTEXT") @NonNull Context context);
     }
 
     private interface UpdateKey<T> extends BiConsumer<AppWidgetHostView, T> { }
diff --git a/quickstep/src/com/android/launcher3/uioverrides/RecentsViewStateController.kt b/quickstep/src/com/android/launcher3/uioverrides/RecentsViewStateController.kt
index 23dc81d..c9f791c 100644
--- a/quickstep/src/com/android/launcher3/uioverrides/RecentsViewStateController.kt
+++ b/quickstep/src/com/android/launcher3/uioverrides/RecentsViewStateController.kt
@@ -21,6 +21,7 @@
 import com.android.app.animation.Interpolators.INSTANT
 import com.android.app.animation.Interpolators.LINEAR
 import com.android.launcher3.Flags.enableDesktopExplodedView
+import com.android.launcher3.Flags.enableGridOnlyOverview
 import com.android.launcher3.Flags.enableLargeDesktopWindowingTile
 import com.android.launcher3.LauncherState
 import com.android.launcher3.anim.AnimatedFloat
@@ -143,7 +144,11 @@
             recentsView,
             TASK_MODALNESS,
             toState.overviewModalness,
-            config.getInterpolator(ANIM_OVERVIEW_MODAL, LINEAR),
+            config.getInterpolator(
+                ANIM_OVERVIEW_MODAL,
+                if (enableGridOnlyOverview() && !toState.isRecentsViewVisible) FINAL_FRAME
+                else LINEAR,
+            ),
         )
 
         val fromState = launcher.stateManager.state
diff --git a/quickstep/src/com/android/launcher3/uioverrides/states/AllAppsState.java b/quickstep/src/com/android/launcher3/uioverrides/states/AllAppsState.java
index b27c6e8..54b4fa2 100644
--- a/quickstep/src/com/android/launcher3/uioverrides/states/AllAppsState.java
+++ b/quickstep/src/com/android/launcher3/uioverrides/states/AllAppsState.java
@@ -23,6 +23,7 @@
 
 import com.android.internal.jank.Cuj;
 import com.android.launcher3.DeviceProfile;
+import com.android.launcher3.Flags;
 import com.android.launcher3.Launcher;
 import com.android.launcher3.LauncherState;
 import com.android.launcher3.R;
@@ -153,7 +154,7 @@
         return new PageAlphaProvider(DECELERATE_2) {
             @Override
             public float getPageAlpha(int pageIndex) {
-                return launcher.getDeviceProfile().isTablet
+                return isWorkspaceVisible(launcher.getDeviceProfile())
                         ? superPageAlphaProvider.getPageAlpha(pageIndex)
                         : 0;
             }
@@ -163,13 +164,17 @@
     @Override
     public int getVisibleElements(Launcher launcher) {
         int elements = ALL_APPS_CONTENT | FLOATING_SEARCH_BAR;
-        // When All Apps is presented on a bottom sheet, HOTSEAT_ICONS are visible.
-        if (launcher.getDeviceProfile().isTablet) {
+        if (isWorkspaceVisible(launcher.getDeviceProfile())) {
             elements |= HOTSEAT_ICONS;
         }
         return elements;
     }
 
+    private static boolean isWorkspaceVisible(DeviceProfile deviceProfile) {
+        // Currently we hide the workspace with the all apps blur flag for simplicity.
+        return deviceProfile.isTablet && !Flags.allAppsBlur();
+    }
+
     @Override
     public int getFloatingSearchBarRestingMarginBottom(Launcher launcher) {
         return 0;
@@ -201,8 +206,12 @@
 
     @Override
     public int getWorkspaceScrimColor(Launcher launcher) {
-        return launcher.getDeviceProfile().shouldShowAllAppsOnSheet()
-                ? launcher.getResources().getColor(R.color.widgets_picker_scrim)
-                : Themes.getAttrColor(launcher, R.attr.allAppsScrimColor);
+        if (!launcher.getDeviceProfile().shouldShowAllAppsOnSheet()) {
+            return Themes.getAttrColor(launcher, R.attr.allAppsScrimColor);
+        }
+        if (Flags.allAppsBlur()) {
+            return Themes.getAttrColor(launcher, R.attr.allAppsScrimColorOverBlur);
+        }
+        return launcher.getResources().getColor(R.color.widgets_picker_scrim);
     }
 }
diff --git a/quickstep/src/com/android/launcher3/uioverrides/states/OverviewModalTaskState.java b/quickstep/src/com/android/launcher3/uioverrides/states/OverviewModalTaskState.java
index 0c0b4fd..ae82f82 100644
--- a/quickstep/src/com/android/launcher3/uioverrides/states/OverviewModalTaskState.java
+++ b/quickstep/src/com/android/launcher3/uioverrides/states/OverviewModalTaskState.java
@@ -15,11 +15,11 @@
  */
 package com.android.launcher3.uioverrides.states;
 
+import static com.android.launcher3.Flags.enableGridOnlyOverview;
 import static com.android.launcher3.logging.StatsLogManager.LAUNCHER_STATE_OVERVIEW;
 
 import android.graphics.Rect;
 
-import com.android.launcher3.Flags;
 import com.android.launcher3.Launcher;
 import com.android.launcher3.LauncherState;
 import com.android.launcher3.views.ActivityContext;
@@ -50,6 +50,9 @@
 
     @Override
     public float[] getOverviewScaleAndOffset(Launcher launcher) {
+        if (enableGridOnlyOverview()) {
+            return super.getOverviewScaleAndOffset(launcher);
+        }
         return getOverviewScaleAndOffsetForModalState(launcher.getOverviewPanel());
     }
 
@@ -65,7 +68,7 @@
 
     @Override
     public boolean isTaskbarStashed(Launcher launcher) {
-        if (Flags.enableGridOnlyOverview()) {
+        if (enableGridOnlyOverview()) {
             return true;
         }
         return super.isTaskbarStashed(launcher);
diff --git a/quickstep/src/com/android/launcher3/uioverrides/states/OverviewState.java b/quickstep/src/com/android/launcher3/uioverrides/states/OverviewState.java
index 963504f..3170df9 100644
--- a/quickstep/src/com/android/launcher3/uioverrides/states/OverviewState.java
+++ b/quickstep/src/com/android/launcher3/uioverrides/states/OverviewState.java
@@ -17,10 +17,12 @@
 
 import static com.android.app.animation.Interpolators.DECELERATE_2;
 import static com.android.launcher3.Flags.enableDesktopExplodedView;
+import static com.android.launcher3.Flags.enableOverviewBackgroundWallpaperBlur;
 import static com.android.launcher3.Flags.enableScalingRevealHomeAnimation;
 import static com.android.launcher3.logging.StatsLogManager.LAUNCHER_STATE_OVERVIEW;
 
 import android.content.Context;
+import android.graphics.Color;
 import android.graphics.Rect;
 import android.os.SystemProperties;
 
@@ -35,6 +37,7 @@
 import com.android.quickstep.util.LayoutUtils;
 import com.android.quickstep.views.RecentsView;
 import com.android.quickstep.views.TaskView;
+import com.android.systemui.shared.system.BlurUtils;
 
 /**
  * Definition for overview state
@@ -158,7 +161,9 @@
 
     @Override
     public int getWorkspaceScrimColor(Launcher launcher) {
-        return Themes.getAttrColor(launcher, R.attr.overviewScrimColor);
+        return enableOverviewBackgroundWallpaperBlur() && BlurUtils.supportsBlursOnWindows()
+                ? Color.TRANSPARENT
+                : Themes.getAttrColor(launcher, R.attr.overviewScrimColor);
     }
 
     @Override
diff --git a/quickstep/src/com/android/launcher3/uioverrides/touchcontrollers/TaskViewDismissTouchController.kt b/quickstep/src/com/android/launcher3/uioverrides/touchcontrollers/TaskViewDismissTouchController.kt
index 454a307..76eb138 100644
--- a/quickstep/src/com/android/launcher3/uioverrides/touchcontrollers/TaskViewDismissTouchController.kt
+++ b/quickstep/src/com/android/launcher3/uioverrides/touchcontrollers/TaskViewDismissTouchController.kt
@@ -63,6 +63,7 @@
     private var hasDismissThresholdHapticRun = false
     private var initialDisplacement: Float = 0f
     private var recentsScaleAnimation: SpringAnimation? = null
+    private var isBlockedDuringDismissal = false
 
     private fun canInterceptTouch(ev: MotionEvent): Boolean =
         when {
@@ -137,6 +138,7 @@
     }
 
     override fun onDragStart(start: Boolean, startDisplacement: Float) {
+        if (isBlockedDuringDismissal) return
         val taskBeingDragged = taskBeingDragged ?: return
 
         initialDisplacement =
@@ -149,6 +151,7 @@
     }
 
     override fun onDrag(displacement: Float): Boolean {
+        if (isBlockedDuringDismissal) return true
         val taskBeingDragged = taskBeingDragged ?: return false
         val currentDisplacement = displacement + initialDisplacement
         val boundedDisplacement =
@@ -204,6 +207,7 @@
     }
 
     override fun onDragEnd(velocity: Float) {
+        if (isBlockedDuringDismissal) return
         val taskBeingDragged = taskBeingDragged ?: return
 
         val currentDisplacement =
@@ -234,6 +238,7 @@
                         if (isDismissing) (dismissLength * verticalFactor).toFloat() else 0f
                     )
                 }
+        isBlockedDuringDismissal = true
         recentsScaleAnimation =
             recentsView.animateRecentsScale(RECENTS_SCALE_DEFAULT).addEndListener { _, _, _, _ ->
                 recentsScaleAnimation = null
@@ -246,6 +251,7 @@
         taskBeingDragged?.translationZ = 0f
         taskBeingDragged = null
         springAnimation = null
+        isBlockedDuringDismissal = false
     }
 
     private fun getRecentsScale(dismissFraction: Float): Float {
diff --git a/quickstep/src/com/android/quickstep/AbsSwipeUpHandler.java b/quickstep/src/com/android/quickstep/AbsSwipeUpHandler.java
index 7574c7f..168b856 100644
--- a/quickstep/src/com/android/quickstep/AbsSwipeUpHandler.java
+++ b/quickstep/src/com/android/quickstep/AbsSwipeUpHandler.java
@@ -136,6 +136,7 @@
 import com.android.launcher3.util.WindowBounds;
 import com.android.quickstep.GestureState.GestureEndTarget;
 import com.android.quickstep.RemoteTargetGluer.RemoteTargetHandle;
+import com.android.quickstep.fallback.window.RecentsWindowFlags;
 import com.android.quickstep.util.ActiveGestureErrorDetector;
 import com.android.quickstep.util.ActiveGestureLog;
 import com.android.quickstep.util.ActiveGestureProtoLogProxy;
@@ -903,7 +904,9 @@
     }
 
     public Intent getLaunchIntent() {
-        return mGestureState.getOverviewIntent();
+        // todo differentiate intent based on if we are on home or in app for overview in window
+        boolean useHomeIntentForWindow = RecentsWindowFlags.getEnableOverviewInWindow();
+        return useHomeIntentForWindow ? getHomeIntent() : mGestureState.getOverviewIntent();
     }
     /**
      * Called when the value of {@link #mCurrentShift} changes
diff --git a/quickstep/src/com/android/quickstep/DesktopSystemShortcut.kt b/quickstep/src/com/android/quickstep/DesktopSystemShortcut.kt
index 914855b..4280baf 100644
--- a/quickstep/src/com/android/quickstep/DesktopSystemShortcut.kt
+++ b/quickstep/src/com/android/quickstep/DesktopSystemShortcut.kt
@@ -82,6 +82,7 @@
                             taskKey.numActivities,
                             taskKey.isTopActivityNoDisplay,
                             taskKey.isActivityStackTransparent,
+                            taskKey.userId,
                         ) -> null
 
                         !taskContainer.task.isDockable -> null
diff --git a/quickstep/src/com/android/quickstep/DisplayModel.kt b/quickstep/src/com/android/quickstep/DisplayModel.kt
index ac94375..3de6fd0 100644
--- a/quickstep/src/com/android/quickstep/DisplayModel.kt
+++ b/quickstep/src/com/android/quickstep/DisplayModel.kt
@@ -22,7 +22,6 @@
 import android.util.SparseArray
 import android.view.Display
 import androidx.core.util.valueIterator
-import com.android.launcher3.util.Executors
 import com.android.quickstep.DisplayModel.DisplayResource
 import java.io.PrintWriter
 
@@ -37,29 +36,24 @@
     private val displayManager = context.getSystemService(Context.DISPLAY_SERVICE) as DisplayManager
     protected val displayResourceArray = SparseArray<RESOURCE_TYPE>()
 
-    private val displayListener: DisplayManager.DisplayListener =
-        (object : DisplayManager.DisplayListener {
-            override fun onDisplayAdded(displayId: Int) {
-                if (DEBUG) Log.d(TAG, "onDisplayAdded: displayId=$displayId")
-                storeDisplayResource(displayId)
-            }
+    fun onDisplayAddSystemDecorations(displayId: Int) {
+        if (DEBUG) Log.d(TAG, "onDisplayAdded: displayId=$displayId")
+        storeDisplayResource(displayId)
+    }
 
-            override fun onDisplayRemoved(displayId: Int) {
-                if (DEBUG) Log.d(TAG, "onDisplayRemoved: displayId=$displayId")
-                deleteDisplayResource(displayId)
-            }
+    fun onDisplayRemoved(displayId: Int) {
+        if (DEBUG) Log.d(TAG, "onDisplayRemoved: displayId=$displayId")
+        deleteDisplayResource(displayId)
+    }
 
-            override fun onDisplayChanged(displayId: Int) {
-                if (DEBUG) Log.d(TAG, "onDisplayChanged: displayId=$displayId")
-            }
-        })
+    fun onDisplayRemoveSystemDecorations(displayId: Int) {
+        if (DEBUG) Log.d(TAG, "onDisplayRemoveSystemDecorations: displayId=$displayId")
+        deleteDisplayResource(displayId)
+    }
 
     protected abstract fun createDisplayResource(display: Display): RESOURCE_TYPE
 
-    protected fun registerDisplayListener() {
-        displayManager.registerDisplayListener(displayListener, Executors.MAIN_EXECUTOR.handler)
-        // In the scenario where displays were added before this display listener was
-        // registered, we should store the DisplayResources for those displays directly.
+    protected fun initializeDisplays() {
         displayManager.displays
             .filter { getDisplayResource(it.displayId) == null }
             .forEach { storeDisplayResource(it.displayId) }
@@ -70,18 +64,19 @@
             displayResource.cleanup()
         }
         displayResourceArray.clear()
-        displayManager.unregisterDisplayListener(displayListener)
     }
 
     fun getDisplayResource(displayId: Int): RESOURCE_TYPE? {
-        if (DEBUG) Log.d(TAG, "get: displayId=$displayId")
+        if (DEBUG) Log.d(TAG, Log.getStackTraceString(Throwable("get: displayId=$displayId")))
         return displayResourceArray[displayId]
     }
 
     fun deleteDisplayResource(displayId: Int) {
         if (DEBUG) Log.d(TAG, "delete: displayId=$displayId")
-        getDisplayResource(displayId)?.cleanup()
-        displayResourceArray.remove(displayId)
+        getDisplayResource(displayId)?.let {
+            it.cleanup()
+            displayResourceArray.remove(displayId)
+        }
     }
 
     fun storeDisplayResource(displayId: Int) {
diff --git a/quickstep/src/com/android/quickstep/ExternalDisplaySystemShortcut.kt b/quickstep/src/com/android/quickstep/ExternalDisplaySystemShortcut.kt
index f97cf9c..3b823f5 100644
--- a/quickstep/src/com/android/quickstep/ExternalDisplaySystemShortcut.kt
+++ b/quickstep/src/com/android/quickstep/ExternalDisplaySystemShortcut.kt
@@ -80,6 +80,7 @@
                             taskKey.numActivities,
                             taskKey.isTopActivityNoDisplay,
                             taskKey.isActivityStackTransparent,
+                            taskKey.userId,
                         ) -> null
 
                         else -> {
diff --git a/quickstep/src/com/android/quickstep/InputConsumer.java b/quickstep/src/com/android/quickstep/InputConsumer.java
index 081ed9d..e5cbc66 100644
--- a/quickstep/src/com/android/quickstep/InputConsumer.java
+++ b/quickstep/src/com/android/quickstep/InputConsumer.java
@@ -63,13 +63,25 @@
             "TYPE_BUBBLE_BAR",              // 16
     };
 
-    InputConsumer NO_OP = () -> TYPE_NO_OP;
+    InputConsumer DEFAULT_NO_OP = createNoOpInputConsumer(Display.DEFAULT_DISPLAY);
+
+    static InputConsumer createNoOpInputConsumer(int displayId) {
+        return new InputConsumer() {
+            @Override
+            public int getType() {
+                return TYPE_NO_OP;
+            }
+
+            @Override
+            public int getDisplayId() {
+                return displayId;
+            }
+        };
+    }
 
     int getType();
 
-    default int getDisplayId() {
-        return Display.DEFAULT_DISPLAY;
-    }
+    int getDisplayId();
 
     /**
      * Returns true if the user has crossed the threshold for it to be an explicit action.
diff --git a/quickstep/src/com/android/quickstep/InputConsumerUtils.kt b/quickstep/src/com/android/quickstep/InputConsumerUtils.kt
index cd3ac12..c8ca534 100644
--- a/quickstep/src/com/android/quickstep/InputConsumerUtils.kt
+++ b/quickstep/src/com/android/quickstep/InputConsumerUtils.kt
@@ -57,7 +57,7 @@
     @JvmStatic
     fun <S : BaseState<S>, T> newConsumer(
         context: Context,
-        resetGestureInputConsumer: ResetGestureInputConsumer?,
+        userUnlocked: Boolean,
         overviewComponentObserver: OverviewComponentObserver,
         deviceState: RecentsAnimationDeviceState,
         previousGestureState: GestureState,
@@ -122,7 +122,8 @@
                     // camera).
                     createDeviceLockedInputConsumer(
                         context,
-                        resetGestureInputConsumer,
+                        userUnlocked,
+                        taskbarManager,
                         deviceState,
                         gestureState,
                         taskAnimationManager,
@@ -131,7 +132,10 @@
                     )
                 } else {
                     getDefaultInputConsumer(
-                        resetGestureInputConsumer,
+                        gestureState.displayId,
+                        userUnlocked,
+                        taskAnimationManager,
+                        taskbarManager,
                         reasonString.append("%scannot start system gesture", SUBSTRING_PREFIX),
                     )
                 }
@@ -153,7 +157,8 @@
             base =
                 newBaseConsumer<S, T>(
                     context,
-                    resetGestureInputConsumer,
+                    userUnlocked,
+                    taskbarManager,
                     overviewComponentObserver,
                     deviceState,
                     previousGestureState,
@@ -172,7 +177,14 @@
                     "cannot start system gesture and recents " +
                         "animation was not running, trying to use default input consumer"
                 )
-            base = getDefaultInputConsumer(resetGestureInputConsumer, reasonString)
+            base =
+                getDefaultInputConsumer(
+                    gestureState.displayId,
+                    userUnlocked,
+                    taskAnimationManager,
+                    taskbarManager,
+                    reasonString,
+                )
         }
         if (deviceState.isGesturalNavMode || gestureState.isTrackpadGesture) {
             handleOrientationSetup(base)
@@ -237,7 +249,14 @@
                                 SUBSTRING_PREFIX,
                             )
                     // Bubbles can handle home gesture itself.
-                    base = getDefaultInputConsumer(resetGestureInputConsumer, reasonString)
+                    base =
+                        getDefaultInputConsumer(
+                            gestureState.displayId,
+                            userUnlocked,
+                            taskAnimationManager,
+                            taskbarManager,
+                            reasonString,
+                        )
                 }
             }
 
@@ -279,7 +298,14 @@
                                 SUBSTRING_PREFIX,
                             )
                     // Bubbles can handle home gesture itself.
-                    base = getDefaultInputConsumer(resetGestureInputConsumer, reasonString)
+                    base =
+                        getDefaultInputConsumer(
+                            gestureState.displayId,
+                            userUnlocked,
+                            taskAnimationManager,
+                            taskbarManager,
+                            reasonString,
+                        )
                 }
             }
 
@@ -374,7 +400,14 @@
                             "%sscreen pinning is active, trying to use default input consumer",
                             SUBSTRING_PREFIX,
                         )
-                base = getDefaultInputConsumer(resetGestureInputConsumer, reasonString)
+                base =
+                    getDefaultInputConsumer(
+                        gestureState.displayId,
+                        userUnlocked,
+                        taskAnimationManager,
+                        taskbarManager,
+                        reasonString,
+                    )
             }
 
             if (deviceState.canTriggerOneHandedAction(event)) {
@@ -411,7 +444,7 @@
             context,
             deviceState,
             inputMonitorCompat,
-            InputConsumer.NO_OP,
+            InputConsumer.createNoOpInputConsumer(gestureState.displayId),
             gestureState,
             motionEvent,
             CompoundString.NO_OP,
@@ -450,7 +483,8 @@
     @JvmStatic
     fun <S : BaseState<S>, T> newBaseConsumer(
         context: Context,
-        resetGestureInputConsumer: ResetGestureInputConsumer?,
+        userUnlocked: Boolean,
+        taskbarManager: TaskbarManager,
         overviewComponentObserver: OverviewComponentObserver,
         deviceState: RecentsAnimationDeviceState,
         previousGestureState: GestureState,
@@ -467,7 +501,8 @@
             // This handles apps showing over the lockscreen (e.g. camera)
             return createDeviceLockedInputConsumer(
                 context,
-                resetGestureInputConsumer,
+                userUnlocked,
+                taskbarManager,
                 deviceState,
                 gestureState,
                 taskAnimationManager,
@@ -521,7 +556,9 @@
 
         return if (gestureState.getContainerInterface<S, T>().isInLiveTileMode()) {
             createOverviewInputConsumer<S, T>(
-                resetGestureInputConsumer,
+                userUnlocked,
+                taskAnimationManager,
+                taskbarManager,
                 deviceState,
                 inputMonitorCompat,
                 previousGestureState,
@@ -534,7 +571,10 @@
             )
         } else if (runningTask == null) {
             getDefaultInputConsumer(
-                resetGestureInputConsumer,
+                gestureState.displayId,
+                userUnlocked,
+                taskAnimationManager,
+                taskbarManager,
                 reasonString.append("%srunning task == null", SUBSTRING_PREFIX),
             )
         } else if (
@@ -543,7 +583,9 @@
                 forceOverviewInputConsumer
         ) {
             createOverviewInputConsumer<S, T>(
-                resetGestureInputConsumer,
+                userUnlocked,
+                taskAnimationManager,
+                taskbarManager,
                 deviceState,
                 inputMonitorCompat,
                 previousGestureState,
@@ -565,7 +607,10 @@
             )
         } else if (deviceState.isGestureBlockedTask(runningTask) || launcherChildActivityResumed) {
             getDefaultInputConsumer(
-                resetGestureInputConsumer,
+                gestureState.displayId,
+                userUnlocked,
+                taskAnimationManager,
+                taskbarManager,
                 reasonString.append(
                     if (launcherChildActivityResumed)
                         "%sis launcher child-task, trying to use default input consumer"
@@ -592,7 +637,8 @@
 
     private fun createDeviceLockedInputConsumer(
         context: Context,
-        resetGestureInputConsumer: ResetGestureInputConsumer?,
+        userUnlocked: Boolean,
+        taskbarManager: TaskbarManager,
         deviceState: RecentsAnimationDeviceState,
         gestureState: GestureState,
         taskAnimationManager: TaskAnimationManager,
@@ -617,7 +663,10 @@
             )
         } else {
             getDefaultInputConsumer(
-                resetGestureInputConsumer,
+                gestureState.displayId,
+                userUnlocked,
+                taskAnimationManager,
+                taskbarManager,
                 reasonString.append(
                     if (deviceState.isFullyGesturalNavMode || gestureState.isTrackpadGesture)
                         "%srunning task == null, trying to use default input consumer"
@@ -631,7 +680,9 @@
     }
 
     private fun <S : BaseState<S>, T> createOverviewInputConsumer(
-        resetGestureInputConsumer: ResetGestureInputConsumer?,
+        userUnlocked: Boolean,
+        taskAnimationManager: TaskAnimationManager,
+        taskbarManager: TaskbarManager,
         deviceState: RecentsAnimationDeviceState,
         inputMonitorCompat: InputMonitorCompat,
         previousGestureState: GestureState,
@@ -642,7 +693,10 @@
         val container: T =
             gestureState.getContainerInterface<S, T>().getCreatedContainer()
                 ?: return getDefaultInputConsumer(
-                    resetGestureInputConsumer,
+                    gestureState.displayId,
+                    userUnlocked,
+                    taskAnimationManager,
+                    taskbarManager,
                     reasonString.append(
                         "%sactivity == null, trying to use default input consumer",
                         SUBSTRING_PREFIX,
@@ -694,24 +748,34 @@
     }
 
     /** Returns the [ResetGestureInputConsumer] if user is unlocked, else NO_OP. */
-    private fun getDefaultInputConsumer(
-        resetGestureInputConsumer: ResetGestureInputConsumer?,
+    @JvmStatic
+    fun getDefaultInputConsumer(
+        displayId: Int,
+        userUnlocked: Boolean,
+        taskAnimationManager: TaskAnimationManager?,
+        taskbarManager: TaskbarManager?,
         reasonString: CompoundString,
     ): InputConsumer {
-        return if (resetGestureInputConsumer != null) {
+        return if (userUnlocked && taskAnimationManager != null && taskbarManager != null) {
             reasonString.append(
-                "%smResetGestureInputConsumer initialized, using ResetGestureInputConsumer",
+                "%sResetGestureInputConsumer available, using ResetGestureInputConsumer",
                 SUBSTRING_PREFIX,
             )
-            resetGestureInputConsumer
+            ResetGestureInputConsumer(displayId, taskAnimationManager) {
+                taskbarManager.getTaskbarForDisplay(displayId)
+            }
         } else {
             reasonString.append(
-                "%smResetGestureInputConsumer not initialized, using no-op input consumer",
+                "%s${
+                    if (userUnlocked) "user is locked"
+                    else if (taskAnimationManager == null) "taskAnimationManager is null"
+                    else "taskbarManager is null"
+                }, using no-op input consumer",
                 SUBSTRING_PREFIX,
             )
-            // mResetGestureInputConsumer isn't initialized until onUserUnlocked(), so reset to
+            // ResetGestureInputConsumer isn't available until onUserUnlocked(), so reset to
             // NO_OP until then (we never want these to be null).
-            InputConsumer.NO_OP
+            InputConsumer.createNoOpInputConsumer(displayId)
         }
     }
 
diff --git a/quickstep/src/com/android/quickstep/OverviewCommandHelper.kt b/quickstep/src/com/android/quickstep/OverviewCommandHelper.kt
index bf87291..6a9c3dd 100644
--- a/quickstep/src/com/android/quickstep/OverviewCommandHelper.kt
+++ b/quickstep/src/com/android/quickstep/OverviewCommandHelper.kt
@@ -28,6 +28,7 @@
 import androidx.annotation.BinderThread
 import androidx.annotation.UiThread
 import androidx.annotation.VisibleForTesting
+import com.android.app.tracing.traceSection
 import com.android.internal.jank.Cuj
 import com.android.launcher3.Flags.enableAltTabKqsOnConnectedDisplays
 import com.android.launcher3.Flags.enableLargeDesktopWindowingTile
@@ -74,7 +75,6 @@
 constructor(
     private val touchInteractionService: TouchInteractionService,
     private val overviewComponentObserver: OverviewComponentObserver,
-    private val taskAnimationManager: TaskAnimationManager,
     private val dispatcherProvider: DispatcherProvider = ProductionDispatchers,
     private val recentsDisplayModel: RecentsDisplayModel,
     private val focusState: FocusState,
@@ -91,27 +91,33 @@
      */
     private var keyboardTaskFocusIndex = -1
 
-    // TODO (b/397942185): get per-display interface
-    private val containerInterface: BaseContainerInterface<*, *>
-        get() = overviewComponentObserver.getContainerInterface(DEFAULT_DISPLAY)
+    private fun getContainerInterface(displayId: Int) =
+        overviewComponentObserver.getContainerInterface(displayId)
 
-    // TODO (b/397942185): get per-display RecentsView
-    private val visibleRecentsView: RecentsView<*, *>?
-        get() = containerInterface.getVisibleRecentsView<RecentsView<*, *>>()
+    private fun getVisibleRecentsView(displayId: Int) =
+        getContainerInterface(displayId).getVisibleRecentsView<RecentsView<*, *>>()
 
     /**
      * Adds a command to be executed next, after all pending tasks are completed. Max commands that
      * can be queued is [.MAX_QUEUE_SIZE]. Requests after reaching that limit will be silently
      * dropped.
+     *
+     * @param type The type of the command
+     * @param onDisplays The display to run the command on
      */
     @BinderThread
-    fun addCommand(type: CommandType): CommandInfo? {
+    @JvmOverloads
+    fun addCommand(
+        type: CommandType,
+        displayId: Int = DEFAULT_DISPLAY,
+        isLastOfBatch: Boolean = true,
+    ): CommandInfo? {
         if (commandQueue.size >= MAX_QUEUE_SIZE) {
             Log.d(TAG, "command not added: $type - queue is full ($commandQueue).")
             return null
         }
 
-        val command = CommandInfo(type)
+        val command = CommandInfo(type, displayId = displayId, isLastOfBatch = isLastOfBatch)
         commandQueue.add(command)
         Log.d(TAG, "command added: $command")
 
@@ -129,6 +135,35 @@
         return command
     }
 
+    @BinderThread
+    fun addCommandsForDisplays(type: CommandType, displayIds: IntArray): CommandInfo? {
+        if (displayIds.isEmpty()) return null
+        var lastCommand: CommandInfo? = null
+        displayIds.forEachIndexed({ i, displayId ->
+            lastCommand = addCommand(type, displayId, i == displayIds.size - 1)
+        })
+        return lastCommand
+    }
+
+    @BinderThread
+    fun addCommandsForAllDisplays(type: CommandType) =
+        addCommandsForDisplays(
+            type,
+            recentsDisplayModel.activeDisplayResources
+                .map { resource -> resource.displayId }
+                .toIntArray(),
+        )
+
+    @BinderThread
+    fun addCommandsForDisplaysExcept(type: CommandType, excludedDisplayId: Int) =
+        addCommandsForDisplays(
+            type,
+            recentsDisplayModel.activeDisplayResources
+                .map { resource -> resource.displayId }
+                .filter { displayId -> displayId != excludedDisplayId }
+                .toIntArray(),
+        )
+
     fun canStartHomeSafely(): Boolean = commandQueue.isEmpty() || commandQueue.first().type == HOME
 
     /** Clear pending or completed commands from the queue */
@@ -143,35 +178,38 @@
      * completion (returns false).
      */
     @UiThread
-    private fun processNextCommand() {
-        val command: CommandInfo =
-            commandQueue.firstOrNull()
-                ?: run {
-                    Log.d(TAG, "no pending commands to be executed.")
-                    return
-                }
-
-        command.status = CommandStatus.PROCESSING
-        Log.d(TAG, "executing command: $command")
-
-        if (enableOverviewCommandHelperTimeout()) {
-            coroutineScope.launch(dispatcherProvider.main) {
-                withTimeout(QUEUE_WAIT_DURATION_IN_MS) {
-                    executeCommandSuspended(command)
-                    ensureActive()
-                    onCommandFinished(command)
-                }
+    private fun processNextCommand(): Unit =
+        traceSection("OverviewCommandHelper.processNextCommand") {
+            val command: CommandInfo? = commandQueue.firstOrNull()
+            if (command == null) {
+                Log.d(TAG, "no pending commands to be executed.")
+                return@traceSection
             }
-        } else {
-            val result = executeCommand(command, onCallbackResult = { onCommandFinished(command) })
-            Log.d(TAG, "command executed: $command with result: $result")
-            if (result) {
-                onCommandFinished(command)
+
+            command.status = CommandStatus.PROCESSING
+            Log.d(TAG, "executing command: $command")
+
+            if (enableOverviewCommandHelperTimeout()) {
+                coroutineScope.launch(dispatcherProvider.main) {
+                    traceSection("OverviewCommandHelper.executeCommandWithTimeout") {
+                        withTimeout(QUEUE_WAIT_DURATION_IN_MS) {
+                            executeCommandSuspended(command)
+                            ensureActive()
+                            onCommandFinished(command)
+                        }
+                    }
+                }
             } else {
-                Log.d(TAG, "waiting for command callback: $command")
+                val result =
+                    executeCommand(command, onCallbackResult = { onCommandFinished(command) })
+                Log.d(TAG, "command executed: $command with result: $result")
+                if (result) {
+                    onCommandFinished(command)
+                } else {
+                    Log.d(TAG, "waiting for command callback: $command")
+                }
             }
         }
-    }
 
     /**
      * Executes the task and returns true if next task can be executed. If false, then the next task
@@ -179,7 +217,7 @@
      */
     @VisibleForTesting
     fun executeCommand(command: CommandInfo, onCallbackResult: () -> Unit): Boolean {
-        val recentsView = visibleRecentsView
+        val recentsView = getVisibleRecentsView(command.displayId)
         Log.d(TAG, "executeCommand: $command - visibleRecentsView: $recentsView")
         return if (recentsView != null) {
             executeWhenRecentsIsVisible(command, recentsView, onCallbackResult)
@@ -227,6 +265,7 @@
                     launchTask(recentsView, taskView, command, onCallbackResult)
                 }
             }
+
             TOGGLE -> {
                 launchTask(
                     recentsView,
@@ -235,6 +274,7 @@
                     onCallbackResult,
                 )
             }
+
             HOME -> {
                 recentsView.startHome()
                 true
@@ -291,6 +331,7 @@
         command: CommandInfo,
         onCallbackResult: () -> Unit,
     ): Boolean {
+        val containerInterface = getContainerInterface(command.displayId)
         val recentsViewContainer = containerInterface.getCreatedContainer()
         val recentsView: RecentsView<*, *>? = recentsViewContainer?.getOverviewPanel()
         val deviceProfile = recentsViewContainer?.getDeviceProfile()
@@ -332,6 +373,7 @@
 
                 if (keyboardTaskFocusIndex == -1) return true
             }
+
             KEYBOARD_INPUT ->
                 if (uiController != null && deviceProfile?.isTablet == true) {
                     if (
@@ -345,6 +387,7 @@
                 } else {
                     keyboardTaskFocusIndex = 0
                 }
+
             HOME -> {
                 ActiveGestureProtoLogProxy.logExecuteHomeCommand()
                 // Although IActivityTaskManager$Stub$Proxy.startActivity is a slow binder call,
@@ -354,12 +397,14 @@
                 touchInteractionService.startActivity(overviewComponentObserver.homeIntent)
                 return true
             }
+
             SHOW ->
                 // When Recents is not currently visible, the command's type is SHOW
                 // when overview is triggered via the keyboard overview button or Action+Tab
                 // keys (Not Alt+Tab which is KQS). The overview button on-screen in 3-button
                 // nav is TYPE_TOGGLE.
                 keyboardTaskFocusIndex = 0
+
             TOGGLE -> {}
         }
 
@@ -375,7 +420,7 @@
                     Log.d(TAG, "switching to Overview state - onAnimationStart: $command")
                     super.onAnimationStart(animation)
                     updateRecentsViewFocus(command)
-                    logShowOverviewFrom(command.type)
+                    logShowOverviewFrom(command)
                 }
 
                 override fun onAnimationEnd(animation: Animator) {
@@ -399,7 +444,7 @@
 
         val gestureState =
             touchInteractionService.createGestureState(
-                focusedDisplayId,
+                command.displayId,
                 GestureState.DEFAULT_STATE,
                 GestureState.TrackpadGestureType.NONE,
             )
@@ -429,7 +474,7 @@
                     }
 
                     updateRecentsViewFocus(command)
-                    logShowOverviewFrom(command.type)
+                    logShowOverviewFrom(command)
                     containerInterface.runOnInitBackgroundStateUI {
                         Log.d(TAG, "recents animation started - onInitBackgroundStateUI: $command")
                         interactionHandler.onGestureEnded(
@@ -453,6 +498,15 @@
                 }
             }
 
+        val taskAnimationManager =
+            recentsDisplayModel.getTaskAnimationManager(command.displayId)
+                ?: run {
+                    Log.e(TAG, "No TaskAnimationManager found for display ${command.displayId}")
+                    ActiveGestureProtoLogProxy.logOnTaskAnimationManagerNotAvailable(
+                        command.displayId
+                    )
+                    return false
+                }
         if (taskAnimationManager.isRecentsAnimationRunning) {
             command.setAnimationCallbacks(
                 taskAnimationManager.continueRecentsAnimation(gestureState)
@@ -515,8 +569,13 @@
     }
 
     private fun updateRecentsViewFocus(command: CommandInfo) {
-        val recentsView: RecentsView<*, *> = visibleRecentsView ?: return
-        if (command.type != KEYBOARD_INPUT && command.type != HIDE && command.type != SHOW) {
+        val recentsView: RecentsView<*, *> = getVisibleRecentsView(command.displayId) ?: return
+        if (
+            command.type != KEYBOARD_INPUT &&
+                command.type != HIDE &&
+                command.type != SHOW &&
+                command.type != TOGGLE
+        ) {
             return
         }
 
@@ -536,7 +595,7 @@
     }
 
     private fun onRecentsViewFocusUpdated(command: CommandInfo) {
-        val recentsView: RecentsView<*, *> = visibleRecentsView ?: return
+        val recentsView: RecentsView<*, *> = getVisibleRecentsView(command.displayId) ?: return
         if (command.type != HIDE || keyboardTaskFocusIndex == PagedView.INVALID_PAGE) {
             return
         }
@@ -554,10 +613,11 @@
         return true
     }
 
-    private fun logShowOverviewFrom(commandType: CommandType) {
+    private fun logShowOverviewFrom(command: CommandInfo) {
+        val containerInterface = getContainerInterface(command.displayId)
         val container = containerInterface.getCreatedContainer() ?: return
         val event =
-            when (commandType) {
+            when (command.type) {
                 SHOW -> LAUNCHER_OVERVIEW_SHOW_OVERVIEW_FROM_KEYBOARD_SHORTCUT
                 HIDE -> LAUNCHER_OVERVIEW_SHOW_OVERVIEW_FROM_KEYBOARD_QUICK_SWITCH
                 TOGGLE -> LAUNCHER_OVERVIEW_SHOW_OVERVIEW_FROM_3_BUTTON
@@ -590,6 +650,8 @@
         var status: CommandStatus = CommandStatus.IDLE,
         val createTime: Long = SystemClock.elapsedRealtime(),
         private var animationCallbacks: RecentsAnimationCallbacks? = null,
+        val displayId: Int = DEFAULT_DISPLAY,
+        val isLastOfBatch: Boolean = true,
     ) {
         fun setAnimationCallbacks(recentsAnimationCallbacks: RecentsAnimationCallbacks) {
             this.animationCallbacks = recentsAnimationCallbacks
diff --git a/quickstep/src/com/android/quickstep/RecentTasksList.java b/quickstep/src/com/android/quickstep/RecentTasksList.java
index cc5b2da..dab78c5 100644
--- a/quickstep/src/com/android/quickstep/RecentTasksList.java
+++ b/quickstep/src/com/android/quickstep/RecentTasksList.java
@@ -511,13 +511,14 @@
             // When the multiple desktop feature is disabled, there can only be up to a single desk
             // on each display, The desk ID doesn't matter and should not be used.
             return MapsKt.map(perDisplayTasks,
-                    it -> new DesktopTask(DesktopVisibilityController.INACTIVE_DESK_ID,
+                    it -> new DesktopTask(DesktopVisibilityController.INACTIVE_DESK_ID, it.getKey(),
                             it.getValue()));
         } else {
             final int deskId = recentTaskInfo.getDeskId();
+            final int displayId = recentTaskInfo.getDeskDisplayId();
             List<Task> tasks = CollectionsKt.map(recentTaskInfo.getTaskInfoList(),
                     it -> createTask(it, minimizedTaskIds));
-            return List.of(new DesktopTask(deskId, tasks));
+            return List.of(new DesktopTask(deskId, displayId, tasks));
         }
     }
 
diff --git a/quickstep/src/com/android/quickstep/RemoteTargetGluer.java b/quickstep/src/com/android/quickstep/RemoteTargetGluer.java
index f96bbcb..943f543 100644
--- a/quickstep/src/com/android/quickstep/RemoteTargetGluer.java
+++ b/quickstep/src/com/android/quickstep/RemoteTargetGluer.java
@@ -68,8 +68,10 @@
      * running tasks
      */
     public RemoteTargetGluer(Context context, BaseContainerInterface sizingStrategy) {
+        // TODO: b/403344864 Make sure init with correct number of RemoteTargetHandle with
+        //  multi-desks feature enabled as well.
         int visibleTasksCount = DesktopVisibilityController.INSTANCE.get(context)
-                .getVisibleDesktopTasksCount();
+                .getVisibleDesktopTasksCountDeprecated();
         if (visibleTasksCount > 0) {
             // Allocate +1 to account for a new task added to the desktop mode
             int numHandles = visibleTasksCount + 1;
diff --git a/quickstep/src/com/android/quickstep/SystemUiProxy.kt b/quickstep/src/com/android/quickstep/SystemUiProxy.kt
index 506f85d..cd87d93 100644
--- a/quickstep/src/com/android/quickstep/SystemUiProxy.kt
+++ b/quickstep/src/com/android/quickstep/SystemUiProxy.kt
@@ -690,10 +690,10 @@
             bubbles?.showDropTarget(show, bubbleBarLocation)
         }
 
-    /** Tells SysUI to move the bubble to full screen. */
-    fun moveBubbleToFullscreen(key: String) {
-        executeWithErrorLog({ "Failed to call moveBubbleToFullscreen"}) {
-            bubbles?.moveBubbleToFullscreen(key)
+    /** Tells SysUI to move the dragged bubble to full screen. */
+    fun moveDraggedBubbleToFullscreen(key: String, dropLocation: Point) {
+        executeWithErrorLog({ "Failed to call moveDraggedBubbleToFullscreen"}) {
+            bubbles?.moveDraggedBubbleToFullscreen(key, dropLocation)
         }
     }
 
diff --git a/quickstep/src/com/android/quickstep/TaskAnimationManager.java b/quickstep/src/com/android/quickstep/TaskAnimationManager.java
index 1c7f23c..4f00381 100644
--- a/quickstep/src/com/android/quickstep/TaskAnimationManager.java
+++ b/quickstep/src/com/android/quickstep/TaskAnimationManager.java
@@ -77,6 +77,7 @@
 
     private boolean mRecentsAnimationStartPending = false;
     private boolean mShouldIgnoreMotionEvents = false;
+    private final int mDisplayId;
 
     private final TaskStackChangeListener mLiveTileRestartListener = new TaskStackChangeListener() {
         @Override
@@ -101,10 +102,13 @@
         }
     };
 
-    TaskAnimationManager(Context ctx, RecentsAnimationDeviceState deviceState) {
+    public TaskAnimationManager(Context ctx, RecentsAnimationDeviceState deviceState,
+            int displayId) {
         mCtx = ctx;
         mDeviceState = deviceState;
+        mDisplayId = displayId;
     }
+
     SystemUiProxy getSystemUiProxy() {
         return SystemUiProxy.INSTANCE.get(mCtx);
     }
@@ -489,6 +493,7 @@
 
     public void dump(String prefix, PrintWriter pw) {
         pw.println(prefix + "TaskAnimationManager:");
+        pw.println(prefix + "\tmDisplayId=" + mDisplayId);
 
         if (enableHandleDelayedGestureCallbacks()) {
             pw.println(prefix + "\tmRecentsAnimationStartPending=" + mRecentsAnimationStartPending);
diff --git a/quickstep/src/com/android/quickstep/TaskViewUtils.java b/quickstep/src/com/android/quickstep/TaskViewUtils.java
index 855ff98..d161d45 100644
--- a/quickstep/src/com/android/quickstep/TaskViewUtils.java
+++ b/quickstep/src/com/android/quickstep/TaskViewUtils.java
@@ -433,9 +433,7 @@
         out.addListener(new AnimationSuccessListener() {
             @Override
             public void onAnimationStart(Animator animation) {
-                for (RemoteTargetHandle remoteTargetHandle : remoteTargetHandles) {
-                    remoteTargetHandle.getTaskViewSimulator().setDrawsBelowRecents(false);
-                }
+                recentsView.setDrawBelowRecents(false, remoteTargetHandles);
             }
 
             @Override
diff --git a/quickstep/src/com/android/quickstep/TopTaskTracker.java b/quickstep/src/com/android/quickstep/TopTaskTracker.java
index b3d9da3..8116a88 100644
--- a/quickstep/src/com/android/quickstep/TopTaskTracker.java
+++ b/quickstep/src/com/android/quickstep/TopTaskTracker.java
@@ -46,6 +46,7 @@
 import com.android.launcher3.util.SplitConfigurationOptions.StageType;
 import com.android.launcher3.util.TraceHelper;
 import com.android.quickstep.dagger.QuickstepBaseAppComponent;
+import com.android.quickstep.util.DesksUtils;
 import com.android.systemui.shared.recents.model.Task;
 import com.android.systemui.shared.recents.model.Task.TaskKey;
 import com.android.systemui.shared.system.ActivityManagerWrapper;
@@ -341,7 +342,8 @@
 
             ArrayList<TaskInfo> tasks = new ArrayList<>(mOrderedTaskList);
             // Strip the pinned task and recents task
-            tasks.removeIf(t -> t.taskId == mPinnedTaskId || isRecentsTask(t));
+            tasks.removeIf(t -> t.taskId == mPinnedTaskId || isRecentsTask(t)
+                    ||  DesksUtils.isDesktopWallpaperTask(t));
             return new CachedTaskInfo(tasks);
         }
     }
diff --git a/quickstep/src/com/android/quickstep/TouchInteractionService.java b/quickstep/src/com/android/quickstep/TouchInteractionService.java
index 741ae7d..7878e68 100644
--- a/quickstep/src/com/android/quickstep/TouchInteractionService.java
+++ b/quickstep/src/com/android/quickstep/TouchInteractionService.java
@@ -35,6 +35,7 @@
 import static com.android.quickstep.GestureState.DEFAULT_STATE;
 import static com.android.quickstep.GestureState.TrackpadGestureType.getTrackpadGestureType;
 import static com.android.quickstep.InputConsumer.TYPE_CURSOR_HOVER;
+import static com.android.quickstep.InputConsumer.createNoOpInputConsumer;
 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;
@@ -98,7 +99,6 @@
 import com.android.quickstep.fallback.window.RecentsWindowSwipeHandler;
 import com.android.quickstep.inputconsumers.BubbleBarInputConsumer;
 import com.android.quickstep.inputconsumers.OneHandedModeInputConsumer;
-import com.android.quickstep.inputconsumers.ResetGestureInputConsumer;
 import com.android.quickstep.util.ActiveGestureLog;
 import com.android.quickstep.util.ActiveGestureLog.CompoundString;
 import com.android.quickstep.util.ActiveGestureProtoLogProxy;
@@ -316,7 +316,10 @@
         @Override
         public void onDisplayAddSystemDecorations(int displayId) {
             executeForTaskbarManager(taskbarManager ->
-                            taskbarManager.onDisplayAddSystemDecorations(displayId));
+                    taskbarManager.onDisplayAddSystemDecorations(displayId));
+
+            executeForRecentsDisplayModel(displayModel ->
+                    displayModel.onDisplayAddSystemDecorations(displayId));
         }
 
         @BinderThread
@@ -327,6 +330,8 @@
             executeForTouchInteractionService(tis -> {
                 tis.mDeviceState.clearSysUIStateFlagsForDisplay(displayId);
             });
+            executeForRecentsDisplayModel(displayModel ->
+                    displayModel.onDisplayRemoved(displayId));
         }
 
         @BinderThread
@@ -334,6 +339,8 @@
         public void onDisplayRemoveSystemDecorations(int displayId) {
             executeForTaskbarManager(taskbarManager ->
                     taskbarManager.onDisplayRemoveSystemDecorations(displayId));
+            executeForRecentsDisplayModel(displayModel ->
+                    displayModel.onDisplayRemoveSystemDecorations(displayId));
         }
 
         @BinderThread
@@ -445,6 +452,15 @@
             }));
         }
 
+        private void executeForRecentsDisplayModel(
+                @NonNull Consumer<RecentsDisplayModel> recentsDisplayModelConsumer) {
+            MAIN_EXECUTOR.execute(() -> executeForTouchInteractionService(tis -> {
+                RecentsDisplayModel recentsDisplayModel = tis.mRecentsDisplayModel;
+                if (recentsDisplayModel == null) return;
+                recentsDisplayModelConsumer.accept(recentsDisplayModel);
+            }));
+        }
+
         /**
          * Returns the {@link TaskbarManager}.
          * <p>
@@ -557,12 +573,11 @@
     private OverviewComponentObserver mOverviewComponentObserver;
     private InputConsumerController mInputConsumer;
     private RecentsAnimationDeviceState mDeviceState;
-    private TaskAnimationManager mTaskAnimationManager;
 
-    private @NonNull InputConsumer mUncheckedConsumer = InputConsumer.NO_OP;
-    private @NonNull InputConsumer mConsumer = InputConsumer.NO_OP;
+    private @NonNull InputConsumer mUncheckedConsumer = InputConsumer.DEFAULT_NO_OP;
+    private @NonNull InputConsumer mConsumer = InputConsumer.DEFAULT_NO_OP;
     private Choreographer mMainChoreographer;
-    private @Nullable ResetGestureInputConsumer mResetGestureInputConsumer;
+    private boolean mUserUnlocked = false;
     private GestureState mGestureState = DEFAULT_STATE;
 
     private InputMonitorDisplayModel mInputMonitorDisplayModel;
@@ -667,7 +682,7 @@
         if (ENABLE_GESTURE_NAV_ON_CONNECTED_DISPLAYS.isTrue()) {
             mInputMonitorDisplayModel = new InputMonitorDisplayModel(this);
         } else {
-            mInputMonitorCompat = new InputMonitorCompat("swipe-up", Display.DEFAULT_DISPLAY);
+            mInputMonitorCompat = new InputMonitorCompat("swipe-up", DEFAULT_DISPLAY);
             mInputEventReceiver = mInputMonitorCompat.getInputReceiver(Looper.getMainLooper(),
                     mMainChoreographer, this::onInputEvent);
         }
@@ -687,13 +702,11 @@
     public void onUserUnlocked() {
         Log.d(TAG, "onUserUnlocked: userId=" + getUserId()
                 + " instance=" + System.identityHashCode(this));
-        mTaskAnimationManager = new TaskAnimationManager(this, mDeviceState);
         mOverviewComponentObserver = OverviewComponentObserver.INSTANCE.get(this);
         mOverviewCommandHelper = new OverviewCommandHelper(this,
-                mOverviewComponentObserver, mTaskAnimationManager, mRecentsDisplayModel,
+                mOverviewComponentObserver, mRecentsDisplayModel,
                 SystemUiProxy.INSTANCE.get(this).getFocusState(), mTaskbarManager);
-        mResetGestureInputConsumer = new ResetGestureInputConsumer(
-                mTaskAnimationManager, mTaskbarManager::getCurrentActivityContext);
+        mUserUnlocked = true;
         mInputConsumer.registerInputConsumer();
         for (int displayId : mDeviceState.getDisplaysWithSysUIState()) {
             onSystemUiFlagsChanged(mDeviceState.getSystemUiStateFlags(displayId), displayId);
@@ -766,14 +779,18 @@
         if (LockedUserState.get(this).isUserUnlocked()) {
             long systemUiStateFlags = mDeviceState.getSystemUiStateFlags(displayId);
             mTaskbarManager.onSystemUiFlagsChanged(systemUiStateFlags, displayId);
-            if (displayId == Display.DEFAULT_DISPLAY) {
+            if (displayId == DEFAULT_DISPLAY) {
                 // The following don't care about non-default displays, at least for now. If they
                 // ever will, they should be taken care of.
                 SystemUiProxy.INSTANCE.get(this).setLastSystemUiStateFlags(systemUiStateFlags);
                 mOverviewComponentObserver.setHomeDisabled(mDeviceState.isHomeDisabled());
                 // TODO b/399371607 - Propagate to taskAnimationManager once overview is multi
                 //  display.
-                mTaskAnimationManager.onSystemUiFlagsChanged(lastSysUIFlags, systemUiStateFlags);
+                TaskAnimationManager taskAnimationManager =
+                        mRecentsDisplayModel.getTaskAnimationManager(displayId);
+                if (taskAnimationManager != null) {
+                    taskAnimationManager.onSystemUiFlagsChanged(lastSysUIFlags, systemUiStateFlags);
+                }
             }
         }
     }
@@ -865,11 +882,18 @@
         boolean isHoverActionWithoutConsumer = enableCursorHoverStates()
                 && isHoverActionWithoutConsumer(event);
 
+        TaskAnimationManager taskAnimationManager = mRecentsDisplayModel.getTaskAnimationManager(
+                displayId);
+        if (taskAnimationManager == null) {
+            Log.e(TAG, "TaskAnimationManager not available for displayId " + displayId);
+            ActiveGestureProtoLogProxy.logOnTaskAnimationManagerNotAvailable(displayId);
+            return;
+        }
         if (enableHandleDelayedGestureCallbacks()) {
             if (action == ACTION_DOWN || isHoverActionWithoutConsumer) {
-                mTaskAnimationManager.notifyNewGestureStart();
+                taskAnimationManager.notifyNewGestureStart();
             }
-            if (mTaskAnimationManager.shouldIgnoreMotionEvents()) {
+            if (taskAnimationManager.shouldIgnoreMotionEvents()) {
                 if (action == ACTION_DOWN || isHoverActionWithoutConsumer) {
                     ActiveGestureProtoLogProxy.logOnInputIgnoringFollowingEvents(displayId);
                 }
@@ -917,7 +941,7 @@
                 } else {
                     reasonString.append(" but event cannot trigger Assistant, "
                             + "consuming gesture as no-op");
-                    mUncheckedConsumer = InputConsumer.NO_OP;
+                    mUncheckedConsumer = createNoOpInputConsumer(displayId);
                 }
             } else if ((!isOneHandedModeActive && isInSwipeUpTouchRegion)
                     || isHoverActionWithoutConsumer || isOnBubbles) {
@@ -934,12 +958,12 @@
                 mGestureState = newGestureState;
                 mConsumer = newConsumer(
                         this,
-                        mResetGestureInputConsumer,
+                        mUserUnlocked,
                         mOverviewComponentObserver,
                         mDeviceState,
                         prevGestureState,
                         mGestureState,
-                        mTaskAnimationManager,
+                        taskAnimationManager,
                         inputMonitorCompat,
                         getSwipeUpHandlerFactory(),
                         this::onConsumerInactive,
@@ -968,19 +992,22 @@
                         + "consuming gesture for one-handed action");
                 // Consume gesture event for triggering one handed feature.
                 mUncheckedConsumer = new OneHandedModeInputConsumer(
-                        this, displayId, mDeviceState, InputConsumer.NO_OP, inputMonitorCompat);
+                        this,
+                        displayId,
+                        mDeviceState,
+                        InputConsumer.createNoOpInputConsumer(displayId), inputMonitorCompat);
             } else {
-                mUncheckedConsumer = InputConsumer.NO_OP;
+                mUncheckedConsumer = InputConsumer.createNoOpInputConsumer(displayId);
             }
         } else {
             // Other events
-            if (mUncheckedConsumer != InputConsumer.NO_OP) {
+            if (mUncheckedConsumer.getType() != InputConsumer.TYPE_NO_OP) {
                 // Only transform the event if we are handling it in a proper consumer
                 mRotationTouchHelper.setOrientationTransformIfNeeded(event);
             }
         }
 
-        if (mUncheckedConsumer != InputConsumer.NO_OP) {
+        if (mUncheckedConsumer.getType() != InputConsumer.TYPE_NO_OP) {
             switch (action) {
                 case ACTION_DOWN:
                     ActiveGestureProtoLogProxy.logOnInputEventActionDown(displayId, reasonString);
@@ -1053,7 +1080,9 @@
             GestureState.TrackpadGestureType trackpadGestureType) {
         final GestureState gestureState;
         TopTaskTracker.CachedTaskInfo taskInfo;
-        if (mTaskAnimationManager.isRecentsAnimationRunning()) {
+        TaskAnimationManager taskAnimationManager = mRecentsDisplayModel.getTaskAnimationManager(
+                displayId);
+        if (taskAnimationManager != null && taskAnimationManager.isRecentsAnimationRunning()) {
             gestureState = new GestureState(
                     mOverviewComponentObserver, displayId, ActiveGestureLog.INSTANCE.getLogId());
             TopTaskTracker.CachedTaskInfo previousTaskInfo = previousGestureState.getRunningTask();
@@ -1100,7 +1129,12 @@
     }
 
     private void reset(int displayId) {
-        mConsumer = mUncheckedConsumer = getDefaultInputConsumer();
+        mConsumer = mUncheckedConsumer = InputConsumerUtils.getDefaultInputConsumer(
+                displayId,
+                mUserUnlocked,
+                mRecentsDisplayModel.getTaskAnimationManager(displayId),
+                mTaskbarManager,
+                CompoundString.NO_OP);
         mGestureState = DEFAULT_STATE;
         // By default, use batching of the input events, but check receiver before using in the rare
         // case that the monitor was disposed before the swipe settled
@@ -1110,29 +1144,6 @@
         }
     }
 
-    private @NonNull InputConsumer getDefaultInputConsumer() {
-        return getDefaultInputConsumer(CompoundString.NO_OP);
-    }
-
-    /**
-     * Returns the {@link ResetGestureInputConsumer} if user is unlocked, else NO_OP.
-     */
-    private @NonNull InputConsumer getDefaultInputConsumer(@NonNull CompoundString reasonString) {
-        if (mResetGestureInputConsumer != null) {
-            reasonString.append(
-                    "%smResetGestureInputConsumer initialized, using ResetGestureInputConsumer",
-                    SUBSTRING_PREFIX);
-            return mResetGestureInputConsumer;
-        } else {
-            reasonString.append(
-                    "%smResetGestureInputConsumer not initialized, using no-op input consumer",
-                    SUBSTRING_PREFIX);
-            // mResetGestureInputConsumer isn't initialized until onUserUnlocked(), so reset to
-            // NO_OP until then (we never want these to be null).
-            return InputConsumer.NO_OP;
-        }
-    }
-
     @Override
     public void onConfigurationChanged(Configuration newConfig) {
         if (!LockedUserState.get(this).isUserUnlocked()) {
@@ -1208,13 +1219,11 @@
             if (createdOverviewContainer != null) {
                 createdOverviewContainer.getDeviceProfile().dump(this, "", pw);
             }
+            resource.getTaskAnimationManager().dump("\t", pw);
         }
         pw.println("\tmConsumer=" + mConsumer.getName());
         ActiveGestureLog.INSTANCE.dump("", pw);
         RecentsModel.INSTANCE.get(this).dump("", pw);
-        if (mTaskAnimationManager != null) {
-            mTaskAnimationManager.dump("", pw);
-        }
         mTaskbarManager.dumpLogs("", pw);
         DesktopVisibilityController.INSTANCE.get(this).dumpLogs("", pw);
         pw.println("ContextualSearchStateManager:");
@@ -1226,22 +1235,28 @@
 
     private AbsSwipeUpHandler createLauncherSwipeHandler(
             GestureState gestureState, long touchTimeMs) {
-        return new LauncherSwipeHandlerV2(this, mTaskAnimationManager,
-                gestureState, touchTimeMs, mTaskAnimationManager.isRecentsAnimationRunning(),
+        TaskAnimationManager taskAnimationManager = mRecentsDisplayModel.getTaskAnimationManager(
+                gestureState.getDisplayId());
+        return new LauncherSwipeHandlerV2(this, taskAnimationManager,
+                gestureState, touchTimeMs, taskAnimationManager.isRecentsAnimationRunning(),
                 mInputConsumer, MSDLPlayerWrapper.INSTANCE.get(this));
     }
 
     private AbsSwipeUpHandler createFallbackSwipeHandler(
             GestureState gestureState, long touchTimeMs) {
-        return new FallbackSwipeHandler(this, mTaskAnimationManager,
-                gestureState, touchTimeMs, mTaskAnimationManager.isRecentsAnimationRunning(),
+        TaskAnimationManager taskAnimationManager = mRecentsDisplayModel.getTaskAnimationManager(
+                gestureState.getDisplayId());
+        return new FallbackSwipeHandler(this, taskAnimationManager,
+                gestureState, touchTimeMs, taskAnimationManager.isRecentsAnimationRunning(),
                 mInputConsumer, MSDLPlayerWrapper.INSTANCE.get(this));
     }
 
     private AbsSwipeUpHandler createRecentsWindowSwipeHandler(
             GestureState gestureState, long touchTimeMs) {
-        return new RecentsWindowSwipeHandler(this, mTaskAnimationManager,
-                gestureState, touchTimeMs, mTaskAnimationManager.isRecentsAnimationRunning(),
+        TaskAnimationManager taskAnimationManager = mRecentsDisplayModel.getTaskAnimationManager(
+                gestureState.getDisplayId());
+        return new RecentsWindowSwipeHandler(this, taskAnimationManager,
+                gestureState, touchTimeMs, taskAnimationManager.isRecentsAnimationRunning(),
                 mInputConsumer, MSDLPlayerWrapper.INSTANCE.get(this));
     }
 
@@ -1252,7 +1267,7 @@
 
         private InputMonitorDisplayModel(Context context) {
             super(context);
-            registerDisplayListener();
+            initializeDisplays();
         }
 
         @NonNull
diff --git a/quickstep/src/com/android/quickstep/fallback/FallbackRecentsStateController.java b/quickstep/src/com/android/quickstep/fallback/FallbackRecentsStateController.java
index 554cea2..7db1813 100644
--- a/quickstep/src/com/android/quickstep/fallback/FallbackRecentsStateController.java
+++ b/quickstep/src/com/android/quickstep/fallback/FallbackRecentsStateController.java
@@ -19,6 +19,7 @@
 import static com.android.app.animation.Interpolators.INSTANT;
 import static com.android.app.animation.Interpolators.LINEAR;
 import static com.android.launcher3.Flags.enableDesktopExplodedView;
+import static com.android.launcher3.Flags.enableGridOnlyOverview;
 import static com.android.launcher3.Flags.enableLargeDesktopWindowingTile;
 import static com.android.launcher3.states.StateAnimationConfig.ANIM_OVERVIEW_MODAL;
 import static com.android.launcher3.states.StateAnimationConfig.ANIM_OVERVIEW_SCALE;
@@ -118,7 +119,9 @@
                 config.getInterpolator(ANIM_OVERVIEW_TRANSLATE_Y, LINEAR));
 
         setter.setFloat(mRecentsView, TASK_MODALNESS, state.getOverviewModalness(),
-                config.getInterpolator(ANIM_OVERVIEW_MODAL, LINEAR));
+                config.getInterpolator(ANIM_OVERVIEW_MODAL,
+                        enableGridOnlyOverview() && !state.isRecentsViewVisible() ? FINAL_FRAME
+                                : LINEAR));
         setter.setFloat(mRecentsView, FULLSCREEN_PROGRESS, state.isFullScreen() ? 1 : 0, LINEAR);
         boolean showAsGrid =
                 state.displayOverviewTasksAsGrid(mRecentsViewContainer.getDeviceProfile());
diff --git a/quickstep/src/com/android/quickstep/fallback/FallbackRecentsView.java b/quickstep/src/com/android/quickstep/fallback/FallbackRecentsView.java
index 8ec97ed..695c77c 100644
--- a/quickstep/src/com/android/quickstep/fallback/FallbackRecentsView.java
+++ b/quickstep/src/com/android/quickstep/fallback/FallbackRecentsView.java
@@ -17,6 +17,7 @@
 
 import static android.app.ActivityTaskManager.INVALID_TASK_ID;
 
+import static com.android.launcher3.Flags.enableGridOnlyOverview;
 import static com.android.quickstep.GestureState.GestureEndTarget.RECENTS;
 import static com.android.quickstep.fallback.RecentsState.DEFAULT;
 import static com.android.quickstep.fallback.RecentsState.MODAL_TASK;
@@ -252,7 +253,14 @@
     @Override
     public void onStateTransitionStart(RecentsState toState) {
         setOverviewStateEnabled(true);
-        setOverviewGridEnabled(toState.displayOverviewTasksAsGrid(mContainer.getDeviceProfile()));
+        if (enableGridOnlyOverview()) {
+            if (toState.displayOverviewTasksAsGrid(mContainer.getDeviceProfile())) {
+                setOverviewGridEnabled(true);
+            }
+        } else {
+            setOverviewGridEnabled(
+                    toState.displayOverviewTasksAsGrid(mContainer.getDeviceProfile()));
+        }
         setOverviewFullscreenEnabled(toState.isFullScreen());
         if (toState == MODAL_TASK) {
             setOverviewSelectEnabled(true);
@@ -271,6 +279,11 @@
     @Override
     public void onStateTransitionComplete(RecentsState finalState) {
         DesktopVisibilityController.INSTANCE.get(mContainer).onLauncherStateChanged(finalState);
+        if (enableGridOnlyOverview()) {
+            if (!finalState.displayOverviewTasksAsGrid(mContainer.getDeviceProfile())) {
+                setOverviewGridEnabled(false);
+            }
+        }
         if (!finalState.isRecentsViewVisible()) {
             // Clean-up logic that occurs when recents is no longer in use/visible.
             reset();
@@ -292,8 +305,7 @@
 
         // disabling this so app icons aren't drawn on top of recent tasks.
         if (isOverlayEnabled && !RecentsWindowFlags.Companion.getEnableOverviewInWindow()) {
-            runActionOnRemoteHandles(remoteTargetHandle ->
-                    remoteTargetHandle.getTaskViewSimulator().setDrawsBelowRecents(true));
+            mBlurUtils.setDrawLiveTileBelowRecents(true);
         }
     }
 
@@ -303,6 +315,7 @@
         if (enabled) {
             RecentsState state = mContainer.getStateManager().getState();
             setDisallowScrollToClearAll(!state.hasClearAllButton());
+            setDisallowScrollToAddDesk(!state.hasAddDeskButton());
         }
     }
 
diff --git a/quickstep/src/com/android/quickstep/fallback/RecentsState.java b/quickstep/src/com/android/quickstep/fallback/RecentsState.java
index 2c1a4eb..00aa109 100644
--- a/quickstep/src/com/android/quickstep/fallback/RecentsState.java
+++ b/quickstep/src/com/android/quickstep/fallback/RecentsState.java
@@ -17,6 +17,7 @@
 
 import static com.android.launcher3.Flags.enableDesktopExplodedView;
 import static com.android.launcher3.Flags.enableDesktopWindowingCarouselDetach;
+import static com.android.launcher3.Flags.enableGridOnlyOverview;
 import static com.android.launcher3.LauncherState.FLAG_CLOSE_POPUPS;
 import static com.android.launcher3.uioverrides.states.BackgroundAppState.getOverviewScaleAndOffsetForBackgroundState;
 import static com.android.launcher3.uioverrides.states.OverviewModalTaskState.getOverviewScaleAndOffsetForModalState;
@@ -197,6 +198,9 @@
 
         @Override
         public float[] getOverviewScaleAndOffset(RecentsViewContainer container) {
+            if (enableGridOnlyOverview()) {
+                return super.getOverviewScaleAndOffset(container);
+            }
             return getOverviewScaleAndOffsetForModalState(container.getOverviewPanel());
         }
     }
diff --git a/quickstep/src/com/android/quickstep/fallback/window/RecentsDisplayModel.kt b/quickstep/src/com/android/quickstep/fallback/window/RecentsDisplayModel.kt
index 12dc177..5b88686 100644
--- a/quickstep/src/com/android/quickstep/fallback/window/RecentsDisplayModel.kt
+++ b/quickstep/src/com/android/quickstep/fallback/window/RecentsDisplayModel.kt
@@ -17,7 +17,9 @@
 package com.android.quickstep.fallback.window
 
 import android.content.Context
+import android.util.Log
 import android.view.Display
+import android.view.Display.DEFAULT_DISPLAY
 import androidx.core.util.valueIterator
 import com.android.launcher3.dagger.ApplicationContext
 import com.android.launcher3.dagger.LauncherAppSingleton
@@ -26,6 +28,8 @@
 import com.android.launcher3.util.WallpaperColorHints
 import com.android.quickstep.DisplayModel
 import com.android.quickstep.FallbackWindowInterface
+import com.android.quickstep.RecentsAnimationDeviceState
+import com.android.quickstep.TaskAnimationManager
 import com.android.quickstep.dagger.QuickstepBaseAppComponent
 import com.android.quickstep.fallback.window.RecentsDisplayModel.RecentsDisplayResource
 import com.android.quickstep.fallback.window.RecentsWindowFlags.Companion.enableOverviewInWindow
@@ -54,9 +58,12 @@
 
     init {
         if (enableOverviewInWindow) {
-            registerDisplayListener()
-            tracker.addCloseable { destroy() }
+            initializeDisplays()
+        } else {
+            // Always create resource for default display
+            storeDisplayResource(DEFAULT_DISPLAY)
         }
+        tracker.addCloseable { destroy() }
     }
 
     override fun createDisplayResource(display: Display): RecentsDisplayResource {
@@ -68,13 +75,19 @@
     }
 
     fun getRecentsWindowManager(displayId: Int): RecentsWindowManager? {
+        if (DEBUG) Log.d(TAG, "getRecentsWindowManager for display $displayId")
         return getDisplayResource(displayId)?.recentsWindowManager
     }
 
     fun getFallbackWindowInterface(displayId: Int): FallbackWindowInterface? {
+        if (DEBUG) Log.d(TAG, "getFallbackWindowInterface for display $displayId")
         return getDisplayResource(displayId)?.fallbackWindowInterface
     }
 
+    fun getTaskAnimationManager(displayId: Int): TaskAnimationManager? {
+        return getDisplayResource(displayId)?.taskAnimationManager
+    }
+
     val activeDisplayResources: Iterable<RecentsDisplayResource>
         get() =
             object : Iterable<RecentsDisplayResource> {
@@ -86,12 +99,20 @@
         val displayContext: Context,
         val wallpaperColorHints: Int,
     ) : DisplayResource() {
-        val recentsWindowManager = RecentsWindowManager(displayContext, wallpaperColorHints)
-        val fallbackWindowInterface: FallbackWindowInterface =
-            FallbackWindowInterface(recentsWindowManager)
+        val recentsWindowManager =
+            if (enableOverviewInWindow) RecentsWindowManager(displayContext, wallpaperColorHints)
+            else null
+        val fallbackWindowInterface =
+            if (enableOverviewInWindow) FallbackWindowInterface(recentsWindowManager) else null
+        val taskAnimationManager =
+            TaskAnimationManager(
+                displayContext,
+                RecentsAnimationDeviceState.INSTANCE.get(displayContext),
+                displayId,
+            )
 
         override fun cleanup() {
-            recentsWindowManager.destroy()
+            recentsWindowManager?.destroy()
         }
 
         override fun dump(prefix: String, writer: PrintWriter) {
diff --git a/quickstep/src/com/android/quickstep/fallback/window/RecentsWindowFlags.kt b/quickstep/src/com/android/quickstep/fallback/window/RecentsWindowFlags.kt
index 9953154..d880774 100644
--- a/quickstep/src/com/android/quickstep/fallback/window/RecentsWindowFlags.kt
+++ b/quickstep/src/com/android/quickstep/fallback/window/RecentsWindowFlags.kt
@@ -29,8 +29,15 @@
         val enableFallbackOverviewInWindow: DesktopModeFlag =
             DesktopModeFlag(Flags::enableFallbackOverviewInWindow, false)
 
+        @JvmField
+        val enableOverviewOnConnectedDisplays: DesktopModeFlag =
+            DesktopModeFlag(Flags::enableOverviewOnConnectedDisplays, false)
+
         @JvmStatic
         val enableOverviewInWindow
-            get() = enableLauncherOverviewInWindow.isTrue || enableFallbackOverviewInWindow.isTrue
+            get() =
+                enableLauncherOverviewInWindow.isTrue ||
+                    enableFallbackOverviewInWindow.isTrue ||
+                    enableOverviewOnConnectedDisplays.isTrue
     }
 }
diff --git a/quickstep/src/com/android/quickstep/inputconsumers/OtherActivityInputConsumer.java b/quickstep/src/com/android/quickstep/inputconsumers/OtherActivityInputConsumer.java
index c8cf58c..2db7573 100644
--- a/quickstep/src/com/android/quickstep/inputconsumers/OtherActivityInputConsumer.java
+++ b/quickstep/src/com/android/quickstep/inputconsumers/OtherActivityInputConsumer.java
@@ -58,7 +58,6 @@
 import com.android.quickstep.RecentsAnimationTargets;
 import com.android.quickstep.RotationTouchHelper;
 import com.android.quickstep.TaskAnimationManager;
-import com.android.quickstep.fallback.window.RecentsWindowFlags;
 import com.android.quickstep.util.CachedEventDispatcher;
 import com.android.quickstep.util.MotionPauseDetector;
 import com.android.quickstep.util.NavBarPosition;
@@ -437,9 +436,7 @@
             mTaskAnimationManager.notifyRecentsAnimationState(mInteractionHandler);
             notifyGestureStarted(true /*isLikelyToStartNewTask*/);
         } else {
-            // todo differentiate intent based on if we are on home or in app for overview in window
-            Intent intent = new Intent(RecentsWindowFlags.Companion.getEnableOverviewInWindow()
-                    ? mInteractionHandler.getHomeIntent() : mInteractionHandler.getLaunchIntent());
+            Intent intent = new Intent(mInteractionHandler.getLaunchIntent());
             intent.putExtra(INTENT_EXTRA_LOG_TRACE_ID, mGestureState.getGestureId());
             mActiveCallbacks = mTaskAnimationManager.startRecentsAnimation(mGestureState, intent,
                     mInteractionHandler);
diff --git a/quickstep/src/com/android/quickstep/inputconsumers/ResetGestureInputConsumer.java b/quickstep/src/com/android/quickstep/inputconsumers/ResetGestureInputConsumer.java
deleted file mode 100644
index 349f4d2..0000000
--- a/quickstep/src/com/android/quickstep/inputconsumers/ResetGestureInputConsumer.java
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * Copyright (C) 2019 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.android.quickstep.inputconsumers;
-
-import android.view.MotionEvent;
-
-import com.android.launcher3.taskbar.TaskbarActivityContext;
-import com.android.quickstep.InputConsumer;
-import com.android.quickstep.TaskAnimationManager;
-
-import java.util.function.Supplier;
-
-/**
- * A NO_OP input consumer which also resets any pending gesture
- */
-public class ResetGestureInputConsumer implements InputConsumer {
-
-    private final TaskAnimationManager mTaskAnimationManager;
-    private final Supplier<TaskbarActivityContext> mActivityContextSupplier;
-
-    public ResetGestureInputConsumer(
-            TaskAnimationManager taskAnimationManager,
-            Supplier<TaskbarActivityContext> activityContextSupplier) {
-        mTaskAnimationManager = taskAnimationManager;
-        mActivityContextSupplier = activityContextSupplier;
-    }
-
-    @Override
-    public int getType() {
-        return TYPE_RESET_GESTURE;
-    }
-
-    @Override
-    public void onMotionEvent(MotionEvent ev) {
-        if (ev.getAction() == MotionEvent.ACTION_DOWN
-                && mTaskAnimationManager.isRecentsAnimationRunning()) {
-            TaskbarActivityContext tac = mActivityContextSupplier.get();
-            mTaskAnimationManager.finishRunningRecentsAnimation(
-                    /* toHome= */ tac != null && !tac.isInApp());
-        }
-    }
-}
diff --git a/quickstep/src/com/android/quickstep/inputconsumers/ResetGestureInputConsumer.kt b/quickstep/src/com/android/quickstep/inputconsumers/ResetGestureInputConsumer.kt
new file mode 100644
index 0000000..96e7943
--- /dev/null
+++ b/quickstep/src/com/android/quickstep/inputconsumers/ResetGestureInputConsumer.kt
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.quickstep.inputconsumers
+
+import android.view.MotionEvent
+import com.android.launcher3.taskbar.TaskbarActivityContext
+import com.android.quickstep.InputConsumer
+import com.android.quickstep.TaskAnimationManager
+import java.util.function.Supplier
+
+/** A NO_OP input consumer which also resets any pending gesture */
+class ResetGestureInputConsumer(
+    private val displayId: Int,
+    private val taskAnimationManager: TaskAnimationManager,
+    private val activityContextSupplier: Supplier<TaskbarActivityContext?>,
+) : InputConsumer {
+    override fun getType() = InputConsumer.TYPE_RESET_GESTURE
+
+    override fun getDisplayId() = displayId
+
+    override fun onMotionEvent(ev: MotionEvent) {
+        if (
+            ev.action == MotionEvent.ACTION_DOWN && taskAnimationManager.isRecentsAnimationRunning
+        ) {
+            val tac = activityContextSupplier.get()
+            taskAnimationManager.finishRunningRecentsAnimation(
+                /* toHome= */ tac != null && !tac.isInApp
+            )
+        }
+    }
+}
diff --git a/quickstep/src/com/android/quickstep/orientation/LandscapePagedViewHandler.kt b/quickstep/src/com/android/quickstep/orientation/LandscapePagedViewHandler.kt
index c4e343e..b8f43a4 100644
--- a/quickstep/src/com/android/quickstep/orientation/LandscapePagedViewHandler.kt
+++ b/quickstep/src/com/android/quickstep/orientation/LandscapePagedViewHandler.kt
@@ -661,7 +661,7 @@
     ): SplitIconPositions {
         return if (Flags.enableOverviewIconMenu()) {
             if (isRtl) {
-                SplitIconPositions(0, -(totalThumbnailHeight - primarySnapshotHeight))
+                SplitIconPositions(-(totalThumbnailHeight - primarySnapshotHeight), 0)
             } else {
                 SplitIconPositions(0, primarySnapshotHeight + dividerSize)
             }
diff --git a/quickstep/src/com/android/quickstep/orientation/SeascapePagedViewHandler.kt b/quickstep/src/com/android/quickstep/orientation/SeascapePagedViewHandler.kt
index 67358bbb..80b50cb 100644
--- a/quickstep/src/com/android/quickstep/orientation/SeascapePagedViewHandler.kt
+++ b/quickstep/src/com/android/quickstep/orientation/SeascapePagedViewHandler.kt
@@ -248,14 +248,14 @@
         val iconCenter = iconAppChipView.getHeight() / 2f
 
         if (isRtl) {
-            iconMenuParams.gravity = Gravity.TOP or Gravity.END
+            iconMenuParams.gravity = Gravity.TOP or Gravity.START
             iconMenuParams.topMargin = iconMenuMargin
             iconMenuParams.marginEnd = thumbnailTopMargin
             // Use half menu height to place the pivot within the X/Y center of icon in the menu.
             iconAppChipView.pivotX = iconMenuParams.width / 2f
             iconAppChipView.pivotY = iconMenuParams.width / 2f
         } else {
-            iconMenuParams.gravity = Gravity.BOTTOM or Gravity.START
+            iconMenuParams.gravity = Gravity.BOTTOM or Gravity.END
             iconMenuParams.topMargin = 0
             iconMenuParams.marginEnd = 0
             iconAppChipView.pivotX = iconCenter
@@ -409,7 +409,7 @@
         if (Flags.enableOverviewIconMenu()) {
             val appChipView = iconView as IconAppChipView
             layoutParams.gravity =
-                if (isRtl) Gravity.TOP or Gravity.END else Gravity.BOTTOM or Gravity.START
+                if (isRtl) Gravity.TOP or Gravity.START else Gravity.BOTTOM or Gravity.END
             appChipView.layoutParams = layoutParams
             appChipView.setSplitTranslationX(0f)
             appChipView.setSplitTranslationY(translationY.toFloat())
diff --git a/quickstep/src/com/android/quickstep/recents/di/RecentsDependencies.kt b/quickstep/src/com/android/quickstep/recents/di/RecentsDependencies.kt
index 553a620..00ef13b 100644
--- a/quickstep/src/com/android/quickstep/recents/di/RecentsDependencies.kt
+++ b/quickstep/src/com/android/quickstep/recents/di/RecentsDependencies.kt
@@ -31,7 +31,7 @@
 import com.android.quickstep.recents.domain.usecase.IsThumbnailValidUseCase
 import com.android.quickstep.recents.domain.usecase.OrganizeDesktopTasksUseCase
 import com.android.quickstep.recents.viewmodel.RecentsViewData
-import com.android.systemui.shared.recents.utilities.PreviewPositionHelper
+import com.android.systemui.shared.recents.utilities.PreviewPositionHelper.PreviewPositionHelperFactory
 import kotlinx.coroutines.CoroutineName
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.SupervisorJob
@@ -203,7 +203,7 @@
                     GetThumbnailPositionUseCase(
                         deviceProfileRepository = inject(scopeId),
                         rotationStateRepository = inject(scopeId),
-                        previewPositionHelper = PreviewPositionHelper(),
+                        previewPositionHelperFactory = PreviewPositionHelperFactory(),
                     )
                 OrganizeDesktopTasksUseCase::class.java -> OrganizeDesktopTasksUseCase()
                 else -> {
diff --git a/quickstep/src/com/android/quickstep/recents/domain/usecase/GetThumbnailPositionUseCase.kt b/quickstep/src/com/android/quickstep/recents/domain/usecase/GetThumbnailPositionUseCase.kt
index 8501382..e83d9f0 100644
--- a/quickstep/src/com/android/quickstep/recents/domain/usecase/GetThumbnailPositionUseCase.kt
+++ b/quickstep/src/com/android/quickstep/recents/domain/usecase/GetThumbnailPositionUseCase.kt
@@ -27,7 +27,7 @@
 class GetThumbnailPositionUseCase(
     private val deviceProfileRepository: RecentsDeviceProfileRepository,
     private val rotationStateRepository: RecentsRotationStateRepository,
-    private val previewPositionHelper: PreviewPositionHelper,
+    private val previewPositionHelperFactory: PreviewPositionHelper.PreviewPositionHelperFactory,
 ) {
     operator fun invoke(
         thumbnailData: ThumbnailData?,
@@ -38,6 +38,7 @@
         val thumbnail =
             thumbnailData?.thumbnail ?: return ThumbnailPosition(Matrix.IDENTITY_MATRIX, false)
 
+        val previewPositionHelper = previewPositionHelperFactory.create()
         previewPositionHelper.updateThumbnailMatrix(
             Rect(0, 0, thumbnail.width, thumbnail.height),
             thumbnailData,
diff --git a/quickstep/src/com/android/quickstep/recents/ui/mapper/TaskUiStateMapper.kt b/quickstep/src/com/android/quickstep/recents/ui/mapper/TaskUiStateMapper.kt
index aa1c236..679daf8 100644
--- a/quickstep/src/com/android/quickstep/recents/ui/mapper/TaskUiStateMapper.kt
+++ b/quickstep/src/com/android/quickstep/recents/ui/mapper/TaskUiStateMapper.kt
@@ -17,6 +17,7 @@
 package com.android.quickstep.recents.ui.mapper
 
 import android.view.View.OnClickListener
+import com.android.launcher3.Flags.enableDesktopExplodedView
 import com.android.quickstep.recents.ui.viewmodel.TaskData
 import com.android.quickstep.task.thumbnail.TaskHeaderUiState
 import com.android.quickstep.task.thumbnail.TaskThumbnailUiState
@@ -99,7 +100,8 @@
         hasHeader: Boolean,
         clickCloseListener: OnClickListener?,
     ) =
-        hasHeader &&
+        enableDesktopExplodedView() &&
+            hasHeader &&
             taskData.icon != null &&
             taskData.titleDescription != null &&
             clickCloseListener != null
diff --git a/quickstep/src/com/android/quickstep/task/thumbnail/TaskContentView.kt b/quickstep/src/com/android/quickstep/task/thumbnail/TaskContentView.kt
index 2dbd811..a40929c 100644
--- a/quickstep/src/com/android/quickstep/task/thumbnail/TaskContentView.kt
+++ b/quickstep/src/com/android/quickstep/task/thumbnail/TaskContentView.kt
@@ -26,7 +26,6 @@
 import android.view.ViewOutlineProvider
 import android.widget.LinearLayout
 import androidx.core.view.isInvisible
-import com.android.launcher3.Flags.enableDesktopExplodedView
 import com.android.launcher3.Flags.enableRefactorTaskThumbnail
 import com.android.launcher3.R
 import com.android.launcher3.util.ViewPool
@@ -65,7 +64,6 @@
 
     override fun onFinishInflate() {
         super.onFinishInflate()
-        maybeCreateHeader()
         createTaskThumbnailView()
     }
 
@@ -122,12 +120,12 @@
         invalidateOutline()
     }
 
-    private fun maybeCreateHeader() {
-        if (enableDesktopExplodedView() && taskHeaderView == null) {
+    private fun createHeaderView(taskHeaderState: TaskHeaderUiState) {
+        if (taskHeaderView == null && taskHeaderState is TaskHeaderUiState.ShowHeader) {
             taskHeaderView =
                 LayoutInflater.from(context).inflate(R.layout.task_header_view, this, false)
                     as TaskHeaderView
-            addView(taskHeaderView)
+            addView(taskHeaderView, 0)
         }
     }
 
@@ -153,6 +151,7 @@
         taskThumbnailUiState: TaskThumbnailUiState,
         taskId: Int?,
     ) {
+        createHeaderView(taskHeaderState)
         taskHeaderView?.setState(taskHeaderState)
         taskThumbnailView?.setState(taskThumbnailUiState, taskId)
     }
diff --git a/quickstep/src/com/android/quickstep/util/BaseDepthController.java b/quickstep/src/com/android/quickstep/util/BaseDepthController.java
index 5d6bb1d..89f1e33 100644
--- a/quickstep/src/com/android/quickstep/util/BaseDepthController.java
+++ b/quickstep/src/com/android/quickstep/util/BaseDepthController.java
@@ -15,6 +15,7 @@
  */
 package com.android.quickstep.util;
 
+import static com.android.launcher3.Flags.enableOverviewBackgroundWallpaperBlur;
 import static com.android.launcher3.Flags.enableScalingRevealHomeAnimation;
 
 import android.app.WallpaperManager;
@@ -24,6 +25,9 @@
 import android.view.AttachedSurfaceControl;
 import android.view.SurfaceControl;
 
+import androidx.annotation.Nullable;
+
+import com.android.launcher3.Flags;
 import com.android.launcher3.Launcher;
 import com.android.launcher3.R;
 import com.android.launcher3.Utilities;
@@ -74,11 +78,14 @@
 
     /**
      * Ratio from 0 to 1, where 0 is fully zoomed out, and 1 is zoomed in.
+     *
      * @see android.service.wallpaper.WallpaperService.Engine#onZoomChanged(float)
      */
     private float mDepth;
 
-    protected SurfaceControl mSurface;
+    protected SurfaceControl mBaseSurface;
+
+    protected SurfaceControl mBaseSurfaceOverride;
 
     // Hints that there is potentially content behind Launcher and that we shouldn't optimize by
     // marking the launcher surface as opaque.  Only used in certain Launcher states.
@@ -99,15 +106,29 @@
 
     protected boolean mWaitingOnSurfaceValidity;
 
+    private SurfaceControl mBlurSurface = null;
+
     public BaseDepthController(Launcher activity) {
         mLauncher = activity;
-        mMaxBlurRadius = activity.getResources().getInteger(R.integer.max_depth_blur_radius);
+        if (Flags.allAppsBlur()) {
+            mMaxBlurRadius = activity.getResources().getDimensionPixelSize(
+                    R.dimen.max_depth_blur_radius_enhanced);
+        } else {
+            mMaxBlurRadius = activity.getResources().getInteger(R.integer.max_depth_blur_radius);
+        }
         mWallpaperManager = activity.getSystemService(WallpaperManager.class);
 
         MultiPropertyFactory<BaseDepthController> depthProperty =
                 new MultiPropertyFactory<>(this, DEPTH, DEPTH_INDEX_COUNT, Float::max);
         stateDepth = depthProperty.get(DEPTH_INDEX_STATE_TRANSITION);
         widgetDepth = depthProperty.get(DEPTH_INDEX_WIDGET);
+        if (enableOverviewBackgroundWallpaperBlur()) {
+            mBlurSurface = new SurfaceControl.Builder()
+                    .setName("Overview Blur")
+                    .setHidden(false)
+                    .build();
+        }
+
     }
 
     protected void setCrossWindowBlursEnabled(boolean isEnabled) {
@@ -145,11 +166,11 @@
         if (!BlurUtils.supportsBlursOnWindows()) {
             return;
         }
-        if (mSurface == null) {
+        if (mBaseSurface == null) {
             Log.d(TAG, "mSurface is null and mCurrentBlur is: " + mCurrentBlur);
             return;
         }
-        if (!mSurface.isValid()) {
+        if (!mBaseSurface.isValid()) {
             Log.d(TAG, "mSurface is not valid");
             mWaitingOnSurfaceValidity = true;
             onInvalidSurface();
@@ -168,10 +189,21 @@
         mCurrentBlur = !mCrossWindowBlursEnabled || hasOpaqueBg || mPauseBlurs
                 ? 0 : (int) (blurAmount * mMaxBlurRadius);
 
-        SurfaceControl.Transaction transaction = new SurfaceControl.Transaction()
-                .setBackgroundBlurRadius(mSurface, mCurrentBlur)
-                .setOpaque(mSurface, isSurfaceOpaque);
-
+        SurfaceControl.Transaction transaction = new SurfaceControl.Transaction();
+        if (enableOverviewBackgroundWallpaperBlur() && mBlurSurface != null) {
+            // Reparent to launcher for full screen blur.
+            transaction.setBackgroundBlurRadius(mBlurSurface, mCurrentBlur)
+                    .reparent(mBlurSurface, mBaseSurface);
+            // Set mBlurSurface to be 1 layer behind mBaseSurface or mBaseSurfaceOverride.
+            if (mBaseSurfaceOverride != null && mBaseSurfaceOverride.isValid()) {
+                transaction.setRelativeLayer(mBlurSurface, mBaseSurfaceOverride, -1);
+            } else {
+                transaction.setRelativeLayer(mBlurSurface, mBaseSurface, -1);
+            }
+        } else {
+            transaction.setBackgroundBlurRadius(mBaseSurface, mCurrentBlur);
+        }
+        transaction.setOpaque(mBaseSurface, isSurfaceOpaque);
         // Set early wake-up flags when we know we're executing an expensive operation, this way
         // SurfaceFlinger will adjust its internal offsets to avoid jank.
         boolean wantsEarlyWakeUp = depth > 0 && depth < 1;
@@ -203,13 +235,26 @@
     }
 
     /**
+     * Sets the lowest surface that should not be blurred.
+     * <p>
+     * Blur is applied to below {@link #mBaseSurfaceOverride}. When set to {@code null}, blur is
+     * applied
+     * to below {@link #mBaseSurface}.
+     * </p>
+     */
+    public void setBaseSurfaceOverride(@Nullable SurfaceControl baseSurfaceOverride) {
+        this.mBaseSurfaceOverride = baseSurfaceOverride;
+        applyDepthAndBlur();
+    }
+
+    /**
      * Sets the specified app target surface to apply the blur to.
      */
-    protected void setSurface(SurfaceControl surface) {
-        if (mSurface != surface || mWaitingOnSurfaceValidity) {
-            mSurface = surface;
+    protected void setBaseSurface(SurfaceControl baseSurface) {
+        if (mBaseSurface != baseSurface || mWaitingOnSurfaceValidity) {
+            mBaseSurface = baseSurface;
             Log.d(TAG, "setSurface:\n\tmWaitingOnSurfaceValidity: " + mWaitingOnSurfaceValidity
-                    + "\n\tmSurface: " + mSurface);
+                    + "\n\tmBaseSurface: " + mBaseSurface);
             applyDepthAndBlur();
         }
     }
diff --git a/quickstep/src/com/android/quickstep/util/BorderAnimator.kt b/quickstep/src/com/android/quickstep/util/BorderAnimator.kt
index 7e51fcf..d1d47b9 100644
--- a/quickstep/src/com/android/quickstep/util/BorderAnimator.kt
+++ b/quickstep/src/com/android/quickstep/util/BorderAnimator.kt
@@ -114,6 +114,8 @@
          *
          * @param borderRadiusPx the radius of the border's corners, in pixels
          * @param borderWidthPx the width of the border, in pixels
+         * @param borderStrokePx the stroke width used to paint the border, in pixels. If smaller
+         *     than border width, it gets drawn at the outside edge of the border.
          * @param boundsBuilder callback to update the border bounds
          * @param targetView the view that will be drawing the border
          * @param contentView the view around which the border will be drawn. this view will be
@@ -128,6 +130,7 @@
         fun createScalingBorderAnimator(
             @Px borderRadiusPx: Int,
             @Px borderWidthPx: Int,
+            @Px borderStrokePx: Int,
             boundsBuilder: (rect: Rect?) -> Unit,
             targetView: View,
             contentView: View,
@@ -139,7 +142,13 @@
             return BorderAnimator(
                 borderRadiusPx,
                 borderColor,
-                ScalingParams(borderWidthPx, boundsBuilder, targetView, contentView),
+                ScalingParams(
+                    borderWidthPx,
+                    borderStrokePx,
+                    boundsBuilder,
+                    targetView,
+                    contentView,
+                ),
                 appearanceDurationMs,
                 disappearanceDurationMs,
                 interpolator,
@@ -151,7 +160,7 @@
         val interpolatedProgress = interpolator.getInterpolation(borderAnimationProgress.value)
         borderAnimationParams.animationProgress = interpolatedProgress
         borderPaint.alpha = (255 * interpolatedProgress).roundToInt()
-        borderPaint.strokeWidth = borderAnimationParams.borderWidth
+        borderPaint.strokeWidth = borderAnimationParams.borderStroke
         borderAnimationParams.targetView.invalidate()
     }
 
@@ -170,7 +179,7 @@
                 /* bottom= */ borderBounds.bottom - alignmentAdjustment,
                 /* rx= */ radius,
                 /* ry= */ radius,
-                /* paint= */ borderPaint
+                /* paint= */ borderPaint,
             )
         }
     }
@@ -212,6 +221,7 @@
     /** Params for handling different target view layout situations. */
     private abstract class BorderAnimationParams(
         @field:Px @param:Px val borderWidthPx: Int,
+        @field:Px @param:Px val borderStrokePx: Int,
         private val boundsBuilder: (rect: Rect) -> Unit,
         val targetView: View,
     ) {
@@ -222,12 +232,12 @@
         abstract val alignmentAdjustmentInset: Int
         abstract val radiusAdjustment: Float
 
-        val borderWidth: Float
-            get() = borderWidthPx * animationProgress
+        val borderStroke: Float
+            get() = borderStrokePx * animationProgress
 
         val alignmentAdjustment: Float
             // Outset the border by half the width to create an outwards-growth animation
-            get() = -borderWidth / 2f + alignmentAdjustmentInset
+            get() = -borderStroke / 2f + alignmentAdjustmentInset
 
         open fun onShowBorder() {
             if (layoutChangeListener == null) {
@@ -253,7 +263,7 @@
         @Px borderWidthPx: Int,
         boundsBuilder: (Rect) -> Unit,
         targetView: View,
-    ) : BorderAnimationParams(borderWidthPx, boundsBuilder, targetView) {
+    ) : BorderAnimationParams(borderWidthPx, borderWidthPx, boundsBuilder, targetView) {
         override val alignmentAdjustmentInset = 0
         override val radiusAdjustment: Float
             get() = -alignmentAdjustment
@@ -265,12 +275,13 @@
      */
     private class ScalingParams(
         @Px borderWidthPx: Int,
+        @Px borderStrokePx: Int,
         boundsBuilder: (rect: Rect?) -> Unit,
         targetView: View,
         private val contentView: View,
-    ) : BorderAnimationParams(borderWidthPx, boundsBuilder, targetView) {
+    ) : BorderAnimationParams(borderWidthPx, borderStrokePx, boundsBuilder, targetView) {
         // Inset the border since we are scaling the container up
-        override val alignmentAdjustmentInset = borderWidthPx
+        override val alignmentAdjustmentInset = borderStrokePx
         override val radiusAdjustment: Float
             // Increase the radius since we are scaling the container up
             get() = alignmentAdjustment
diff --git a/quickstep/src/com/android/quickstep/util/DesksUtils.kt b/quickstep/src/com/android/quickstep/util/DesksUtils.kt
index ccfdbb9..521ba27 100644
--- a/quickstep/src/com/android/quickstep/util/DesksUtils.kt
+++ b/quickstep/src/com/android/quickstep/util/DesksUtils.kt
@@ -16,28 +16,38 @@
 
 package com.android.quickstep.util
 
-import android.content.Context
+import android.app.TaskInfo
+import android.content.ComponentName
+import android.content.res.Resources
 import android.window.DesktopExperienceFlags
 import com.android.systemui.shared.recents.model.Task
 
 class DesksUtils {
     companion object {
+        val sysUiPackage =
+            Resources.getSystem().getString(com.android.internal.R.string.config_systemUi)
+
         @JvmStatic
         fun areMultiDesksFlagsEnabled() =
-            DesktopExperienceFlags.ENABLE_MULTIPLE_DESKTOPS_BACKEND.isTrue() &&
-                DesktopExperienceFlags.ENABLE_MULTIPLE_DESKTOPS_FRONTEND.isTrue()
+            DesktopExperienceFlags.ENABLE_MULTIPLE_DESKTOPS_BACKEND.isTrue &&
+                DesktopExperienceFlags.ENABLE_MULTIPLE_DESKTOPS_FRONTEND.isTrue
 
         /** Returns true if this [task] contains the [DesktopWallpaperActivity]. */
         @JvmStatic
-        fun isDesktopWallpaperTask(context: Context, task: Task): Boolean {
-            val sysUiPackage =
-                context.getResources().getString(com.android.internal.R.string.config_systemUi)
-            val component = task.key.component
-            if (component != null) {
-                return component.className.contains("DesktopWallpaperActivity") &&
-                    component.packageName.contains(sysUiPackage)
-            }
-            return false
+        fun isDesktopWallpaperTask(task: Task) =
+            task.key.component?.let(::isDesktopWallpaperComponent) == true
+
+        @JvmStatic
+        fun isDesktopWallpaperTask(taskInfo: TaskInfo): Boolean {
+            // TODO: b/403118101 - In some launcher tests, there is a task with baseIntent set to
+            // null. Remove this check after finding out how that task is created.
+            if (taskInfo.baseIntent == null) return false
+            return taskInfo.baseIntent.component?.let(::isDesktopWallpaperComponent) == true
         }
+
+        @JvmStatic
+        fun isDesktopWallpaperComponent(component: ComponentName) =
+            component.className.contains("DesktopWallpaperActivity") &&
+                component.packageName.contains(sysUiPackage)
     }
 }
diff --git a/quickstep/src/com/android/quickstep/util/DesktopTask.kt b/quickstep/src/com/android/quickstep/util/DesktopTask.kt
index fbe3bc6..7c27293 100644
--- a/quickstep/src/com/android/quickstep/util/DesktopTask.kt
+++ b/quickstep/src/com/android/quickstep/util/DesktopTask.kt
@@ -17,22 +17,27 @@
 
 import com.android.quickstep.views.TaskViewType
 import com.android.systemui.shared.recents.model.Task
+import java.util.Objects
 
 /**
  * A [Task] container that can contain N number of tasks that are part of the desktop in recent
- * tasks list. Note that desktops can be empty with no tasks in them. The [deskId] makes sense only
- * when the multiple desks feature is enabled.
+ * tasks list. Note that desktops can be empty with no tasks in them. The [deskId], [displayId]
+ * makes sense only when the multiple desks feature is enabled.
  */
-class DesktopTask(val deskId: Int, tasks: List<Task>) : GroupTask(tasks, TaskViewType.DESKTOP) {
+class DesktopTask(val deskId: Int, val displayId: Int, tasks: List<Task>) :
+    GroupTask(tasks, TaskViewType.DESKTOP) {
 
-    override fun copy() = DesktopTask(deskId, tasks)
+    override fun copy() = DesktopTask(deskId, displayId, tasks)
 
-    override fun toString() = "type=$taskViewType deskId=$deskId tasks=$tasks"
+    override fun toString() = "type=$taskViewType deskId=$deskId displayId=$displayId tasks=$tasks"
 
     override fun equals(o: Any?): Boolean {
         if (this === o) return true
         if (o !is DesktopTask) return false
         if (deskId != o.deskId) return false
+        if (displayId != o.displayId) return false
         return super.equals(o)
     }
+
+    override fun hashCode() = Objects.hash(super.hashCode(), deskId, displayId)
 }
diff --git a/quickstep/src/com/android/quickstep/util/GroupTask.kt b/quickstep/src/com/android/quickstep/util/GroupTask.kt
index add8821..2b754e2 100644
--- a/quickstep/src/com/android/quickstep/util/GroupTask.kt
+++ b/quickstep/src/com/android/quickstep/util/GroupTask.kt
@@ -86,6 +86,8 @@
             return TaskItemInfo(task.task.key.id, wii)
         }
     }
+
+    override fun hashCode() = super.hashCode()
 }
 
 /**
diff --git a/quickstep/src/com/android/quickstep/util/InputProxyHandlerFactory.java b/quickstep/src/com/android/quickstep/util/InputProxyHandlerFactory.java
index 843619d..9aded89 100644
--- a/quickstep/src/com/android/quickstep/util/InputProxyHandlerFactory.java
+++ b/quickstep/src/com/android/quickstep/util/InputProxyHandlerFactory.java
@@ -35,8 +35,8 @@
     private final GestureState mGestureState;
 
     @UiThread
-    public InputProxyHandlerFactory(BaseContainerInterface activityInterface,
-            GestureState gestureState) {
+    public InputProxyHandlerFactory(
+            BaseContainerInterface activityInterface, GestureState gestureState) {
         mContainerInterface = activityInterface;
         mGestureState = gestureState;
     }
@@ -47,7 +47,8 @@
     @Override
     public InputConsumer get() {
         RecentsViewContainer container = mContainerInterface.getCreatedContainer();
-        return container == null ? InputConsumer.NO_OP
+        return container == null
+                ? InputConsumer.createNoOpInputConsumer(mGestureState.getDisplayId())
                 : new OverviewInputConsumer(mGestureState, container, null, true);
     }
 }
diff --git a/quickstep/src/com/android/quickstep/util/SwipePipToHomeAnimator.java b/quickstep/src/com/android/quickstep/util/SwipePipToHomeAnimator.java
index d2f9652..54ac1cf 100644
--- a/quickstep/src/com/android/quickstep/util/SwipePipToHomeAnimator.java
+++ b/quickstep/src/com/android/quickstep/util/SwipePipToHomeAnimator.java
@@ -137,7 +137,8 @@
         mDestinationBoundsTransformed.set(destinationBoundsTransformed);
         mSurfaceTransactionHelper = new PipSurfaceTransactionHelper(cornerRadius, shadowRadius);
 
-        final float aspectRatio = destinationBounds.width() / (float) destinationBounds.height();
+        final Rational aspectRatio = new Rational(
+                destinationBounds.width(), destinationBounds.height());
         String reasonForCreateOverlay = null; // For debugging purpose.
 
         // Slightly larger app bounds to allow for off by 1 pixel source-rect-hint errors.
@@ -158,16 +159,22 @@
             // not a valid rectangle to use for cropping app surface
             reasonForCreateOverlay = "Source rect hint exceeds display bounds " + sourceRectHint;
             sourceRectHint.setEmpty();
-        } else if (!PictureInPictureParams.isSameAspectRatio(sourceRectHint,
-                new Rational(destinationBounds.width(), destinationBounds.height()))) {
-            // The source rect hint does not aspect ratio
-            reasonForCreateOverlay = "Source rect hint does not match aspect ratio "
-                    + sourceRectHint + " aspect ratio " + aspectRatio;
-            sourceRectHint.setEmpty();
+        } else {
+            final Rational srcAspectRatio = new Rational(
+                    sourceRectHint.width(), sourceRectHint.height());
+            if (!PictureInPictureParams.isSameAspectRatio(destinationBounds, srcAspectRatio)) {
+                // The aspect ratio of destination bounds does not match source rect hint.
+                // We use the aspect ratio of source rect hint to check against destination bounds
+                // here to avoid upscaling error.
+                reasonForCreateOverlay = "Source rect hint:" + sourceRectHint
+                        + " does not match destination bounds:" + destinationBounds;
+                sourceRectHint.setEmpty();
+            }
         }
 
         if (sourceRectHint.isEmpty()) {
-            mSourceRectHint.set(getEnterPipWithOverlaySrcRectHint(appBounds, aspectRatio));
+            mSourceRectHint.set(
+                    getEnterPipWithOverlaySrcRectHint(appBounds, aspectRatio.floatValue()));
             mPipContentOverlay = new PipContentOverlay.PipAppIconOverlay(view.getContext(),
                     mAppBounds, mDestinationBounds,
                     new IconProvider(context).getIcon(mActivityInfo), appIconSizePx);
diff --git a/quickstep/src/com/android/quickstep/views/BlurUtils.kt b/quickstep/src/com/android/quickstep/views/BlurUtils.kt
new file mode 100644
index 0000000..d6b2a05
--- /dev/null
+++ b/quickstep/src/com/android/quickstep/views/BlurUtils.kt
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.quickstep.views
+
+import com.android.launcher3.Flags.enableOverviewBackgroundWallpaperBlur
+import com.android.quickstep.RemoteTargetGluer.RemoteTargetHandle
+
+/** Applies blur either behind launcher surface or live tile app. */
+class BlurUtils(private val recentsView: RecentsView<*, *>) {
+
+    fun setDrawLiveTileBelowRecents(drawBelowRecents: Boolean) {
+        val liveTileRemoteTargetHandles =
+            if (
+                recentsView.remoteTargetHandles != null &&
+                    recentsView.recentsAnimationController != null
+            )
+                recentsView.remoteTargetHandles
+            else null
+        setDrawBelowRecents(drawBelowRecents, liveTileRemoteTargetHandles)
+    }
+
+    /**
+     * Set surface in [remoteTargetHandles] to be above or below Recents layer, and update the base
+     * layer to apply blur to in BaseDepthController.
+     */
+    fun setDrawBelowRecents(
+        drawBelowRecents: Boolean,
+        remoteTargetHandles: Array<RemoteTargetHandle>? = null,
+    ) {
+        remoteTargetHandles?.forEach { it.taskViewSimulator.setDrawsBelowRecents(drawBelowRecents) }
+        if (enableOverviewBackgroundWallpaperBlur()) {
+            recentsView.depthController?.setBaseSurfaceOverride(
+                // Blurs behind launcher layer.
+                if (!drawBelowRecents || remoteTargetHandles == null) {
+                    null
+                } else {
+                    // Blurs behind live tile. blur will be applied behind window
+                    // which farthest from user in case of desktop and split apps.
+                    remoteTargetHandles
+                        .maxByOrNull { it.transformParams.targetSet.firstAppTarget.leash.layerId }
+                        ?.transformParams
+                        ?.targetSet
+                        ?.firstAppTarget
+                        ?.leash
+                }
+            )
+        }
+    }
+}
diff --git a/quickstep/src/com/android/quickstep/views/DesktopTaskView.kt b/quickstep/src/com/android/quickstep/views/DesktopTaskView.kt
index 27657b4..8876633 100644
--- a/quickstep/src/com/android/quickstep/views/DesktopTaskView.kt
+++ b/quickstep/src/com/android/quickstep/views/DesktopTaskView.kt
@@ -25,6 +25,7 @@
 import android.util.AttributeSet
 import android.util.Log
 import android.util.Size
+import android.view.Display.INVALID_DISPLAY
 import android.view.Gravity
 import android.view.View
 import android.view.ViewStub
@@ -59,6 +60,7 @@
 import com.android.quickstep.task.thumbnail.TaskThumbnailView
 import com.android.quickstep.util.DesktopTask
 import com.android.quickstep.util.RecentsOrientedState
+import com.android.wm.shell.shared.desktopmode.DesktopModeStatus.enableMultipleDesktops
 import kotlin.math.roundToInt
 
 /** TaskView that contains all tasks that are part of the desktop. */
@@ -69,7 +71,10 @@
         type = TaskViewType.DESKTOP,
         thumbnailFullscreenParams = DesktopFullscreenDrawParams(context),
     ) {
-    var deskId = DesktopVisibilityController.INACTIVE_DESK_ID
+    val deskId
+        get() = desktopTask?.deskId ?: DesktopVisibilityController.INACTIVE_DESK_ID
+
+    private var desktopTask: DesktopTask? = null
 
     private val contentViewFullscreenParams = FullscreenDrawParams(context)
 
@@ -112,6 +117,14 @@
             positionTaskWindows()
         }
 
+    override val displayId: Int
+        get() =
+            if (enableMultipleDesktops(context)) {
+                desktopTask?.displayId ?: INVALID_DISPLAY
+            } else {
+                super.displayId
+            }
+
     private fun getRemoteTargetHandle(taskId: Int): RemoteTargetHandle? =
         remoteTargetHandles?.firstOrNull {
             it.transformParams.targetSet.firstAppTargetTaskId == taskId
@@ -284,7 +297,7 @@
         orientedState: RecentsOrientedState,
         taskOverlayFactory: TaskOverlayFactory,
     ) {
-        deskId = desktopTask.deskId
+        this.desktopTask = desktopTask
         // TODO(b/370495260): Minimized tasks should not be filtered with desktop exploded view
         // support.
         // Minimized tasks should not be shown in Overview.
@@ -336,7 +349,7 @@
 
     override fun onRecycle() {
         super.onRecycle()
-        deskId = DesktopVisibilityController.INACTIVE_DESK_ID
+        desktopTask = null
         explodeProgress = 0.0f
         viewModel = null
         visibility = VISIBLE
diff --git a/quickstep/src/com/android/quickstep/views/GroupedTaskView.kt b/quickstep/src/com/android/quickstep/views/GroupedTaskView.kt
index 71a4dde..10a2e90 100644
--- a/quickstep/src/com/android/quickstep/views/GroupedTaskView.kt
+++ b/quickstep/src/com/android/quickstep/views/GroupedTaskView.kt
@@ -182,7 +182,6 @@
         val splitBoundsConfig = splitBoundsConfig ?: return
         val deviceProfile = container.deviceProfile
         val taskIconHeight = deviceProfile.overviewTaskIconSizePx
-        val isRtl = layoutDirection == LAYOUT_DIRECTION_RTL
         val inSplitSelection = getThisTaskCurrentlyInSplitSelection() != INVALID_TASK_ID
         var oneIconHiddenDueToSmallWidth = false
 
@@ -211,6 +210,7 @@
         }
 
         if (enableOverviewIconMenu()) {
+            val isDeviceRtl = Utilities.isRtl(resources)
             val groupedTaskViewSizes =
                 pagedOrientationHandler.getGroupedTaskViewSizes(
                     deviceProfile,
@@ -226,7 +226,7 @@
                 groupedTaskViewSizes.first.y,
                 layoutParams.height,
                 layoutParams.width,
-                isRtl,
+                isDeviceRtl,
                 deviceProfile,
                 splitBoundsConfig,
                 inSplitSelection,
@@ -241,7 +241,7 @@
                 leftTopTaskContainer.taskContentView.measuredHeight,
                 measuredHeight,
                 measuredWidth,
-                isRtl,
+                isLayoutRtl,
                 deviceProfile,
                 splitBoundsConfig,
                 inSplitSelection,
diff --git a/quickstep/src/com/android/quickstep/views/IconAppChipView.kt b/quickstep/src/com/android/quickstep/views/IconAppChipView.kt
index c20aa11..7683a15 100644
--- a/quickstep/src/com/android/quickstep/views/IconAppChipView.kt
+++ b/quickstep/src/com/android/quickstep/views/IconAppChipView.kt
@@ -122,6 +122,9 @@
             field = max(value, minMaxWidth)
         }
 
+    var isExpanded: Boolean = false
+        private set
+
     override fun onFinishInflate() {
         super.onFinishInflate()
         iconView = findViewById(R.id.icon_view)
@@ -356,6 +359,7 @@
                 ObjectAnimator.ofFloat(iconArrowView, SCALE_Y, -1f),
             )
             animator!!.setDuration(MENU_BACKGROUND_REVEAL_DURATION.toLong())
+            isExpanded = true
         } else {
             // Clip expanded text with reveal animation so it doesn't go beyond the edge of the menu
             val expandedTextClipAnim =
@@ -390,6 +394,7 @@
                 ObjectAnimator.ofFloat(iconArrowView, SCALE_Y, 1f),
             )
             animator!!.setDuration(MENU_BACKGROUND_HIDE_DURATION.toLong())
+            isExpanded = false
         }
 
         if (!animated) animator!!.duration = 0
@@ -416,6 +421,17 @@
         }
     }
 
+    override fun focusSearch(direction: Int): View? {
+        if (mParent == null) return null
+        return when (direction) {
+            FOCUS_RIGHT,
+            FOCUS_DOWN -> mParent.focusSearch(this, View.FOCUS_FORWARD)
+            FOCUS_UP,
+            FOCUS_LEFT -> mParent.focusSearch(this, View.FOCUS_BACKWARD)
+            else -> super.focusSearch(direction)
+        }
+    }
+
     override fun asView(): View = this
 
     private companion object {
diff --git a/quickstep/src/com/android/quickstep/views/LauncherRecentsView.java b/quickstep/src/com/android/quickstep/views/LauncherRecentsView.java
index 0f1c294..c1282b9 100644
--- a/quickstep/src/com/android/quickstep/views/LauncherRecentsView.java
+++ b/quickstep/src/com/android/quickstep/views/LauncherRecentsView.java
@@ -18,7 +18,9 @@
 import static android.app.ActivityTaskManager.INVALID_TASK_ID;
 import static android.window.DesktopModeFlags.ENABLE_DESKTOP_WINDOWING_WALLPAPER_ACTIVITY;
 
+import static com.android.launcher3.Flags.enableGridOnlyOverview;
 import static com.android.launcher3.LauncherState.CLEAR_ALL_BUTTON;
+import static com.android.launcher3.LauncherState.ADD_DESK_BUTTON;
 import static com.android.launcher3.LauncherState.NORMAL;
 import static com.android.launcher3.LauncherState.OVERVIEW;
 import static com.android.launcher3.LauncherState.OVERVIEW_MODAL_TASK;
@@ -150,7 +152,14 @@
     public void onStateTransitionStart(LauncherState toState) {
         setOverviewStateEnabled(toState.isRecentsViewVisible);
 
-        setOverviewGridEnabled(toState.displayOverviewTasksAsGrid(mContainer.getDeviceProfile()));
+        if (enableGridOnlyOverview()) {
+            if (toState.displayOverviewTasksAsGrid(mContainer.getDeviceProfile())) {
+                setOverviewGridEnabled(true);
+            }
+        } else {
+            setOverviewGridEnabled(
+                    toState.displayOverviewTasksAsGrid(mContainer.getDeviceProfile()));
+        }
         setOverviewFullscreenEnabled(toState.getOverviewFullscreenProgress() == 1);
         if (toState == OVERVIEW_MODAL_TASK) {
             setOverviewSelectEnabled(true);
@@ -169,6 +178,11 @@
     @Override
     public void onStateTransitionComplete(LauncherState finalState) {
         DesktopVisibilityController.INSTANCE.get(mContainer).onLauncherStateChanged(finalState);
+        if (enableGridOnlyOverview()) {
+            if (!finalState.displayOverviewTasksAsGrid(mContainer.getDeviceProfile())) {
+                setOverviewGridEnabled(false);
+            }
+        }
 
         if (!finalState.isRecentsViewVisible) {
             // Clean-up logic that occurs when recents is no longer in use/visible.
@@ -184,10 +198,8 @@
         if (finalState.isRecentsViewVisible && finalState != OVERVIEW_MODAL_TASK) {
             setTaskBorderEnabled(true);
         }
-
         if (isOverlayEnabled) {
-            runActionOnRemoteHandles(remoteTargetHandle ->
-                    remoteTargetHandle.getTaskViewSimulator().setDrawsBelowRecents(true));
+            mBlurUtils.setDrawLiveTileBelowRecents(true);
         }
     }
 
@@ -198,7 +210,10 @@
             LauncherState state = getStateManager().getState();
             boolean hasClearAllButton = (state.getVisibleElements(mContainer)
                     & CLEAR_ALL_BUTTON) != 0;
+            boolean hasAddDeskButton = (state.getVisibleElements(mContainer)
+                    & ADD_DESK_BUTTON) != 0;
             setDisallowScrollToClearAll(!hasClearAllButton);
+            setDisallowScrollToAddDesk(!hasAddDeskButton);
         }
     }
 
@@ -276,7 +291,7 @@
         GestureState.GestureEndTarget endTarget = mCurrentGestureEndTarget;
         if (endTarget == GestureState.GestureEndTarget.LAST_TASK
                 && desktopVisibilityController.isInDesktopModeAndNotInOverview(
-                        mContainer.getDisplayId())) {
+                mContainer.getDisplayId())) {
             // Recents gesture was cancelled and we are returning to the previous task.
             // After super class has handled clean up, show desktop apps on top again
             showDesktopApps = true;
diff --git a/quickstep/src/com/android/quickstep/views/RecentsDismissUtils.kt b/quickstep/src/com/android/quickstep/views/RecentsDismissUtils.kt
index 4ce18f5..db18394 100644
--- a/quickstep/src/com/android/quickstep/views/RecentsDismissUtils.kt
+++ b/quickstep/src/com/android/quickstep/views/RecentsDismissUtils.kt
@@ -82,6 +82,7 @@
                             runTaskGridReflowSpringAnimation(
                                 draggedTaskView,
                                 getDismissedTaskGapForReflow(draggedTaskView),
+                                onEndRunnable,
                             )
                         } else {
                             recentsView.dismissTaskView(
@@ -89,70 +90,94 @@
                                 /* animateTaskView = */ false,
                                 /* removeTask = */ true,
                             )
+                            onEndRunnable()
                         }
                     } else {
                         recentsView.onDismissAnimationEnds()
+                        onEndRunnable()
                     }
-                    onEndRunnable()
                 }
         if (!isDismissing) {
-            addNeighboringSpringAnimationsForDismissCancel(
+            addNeighborSettlingSpringAnimations(
                 draggedTaskView,
                 draggedTaskViewSpringAnimation,
+                driverProgressThreshold = 0f,
+                isSpringDirectionVertical = true,
             )
         }
         return draggedTaskViewSpringAnimation
     }
 
-    private fun addNeighboringSpringAnimationsForDismissCancel(
+    private fun addNeighborSettlingSpringAnimations(
         draggedTaskView: TaskView,
-        draggedTaskViewSpringAnimation: SpringAnimation,
+        springAnimationDriver: SpringAnimation,
+        tasksToExclude: List<TaskView> = emptyList(),
+        driverProgressThreshold: Float,
+        isSpringDirectionVertical: Boolean,
     ) {
         // Empty spring animation exists for conditional start, and to drive neighboring springs.
         val neighborsToSettle =
             SpringAnimation(FloatValueHolder()).setSpring(createExpressiveDismissSpringForce())
-        var lastPosition = 0f
-        var startSettling = false
-        draggedTaskViewSpringAnimation.addUpdateListener { _, value, velocity ->
-            // Start the settling animation the first time the dragged task passes the origin (from
-            // negative displacement to positive displacement). We do not check for an exact value
-            // to compare to, as the update listener does not necessarily hit every value (e.g. a
-            // value of zero). Do not check again once it has started settling, as a spring can
-            // bounce past the origin multiple times depending on the stiffness and damping ratio.
-            if (startSettling) return@addUpdateListener
-            if (lastPosition < 0 && value >= 0) {
-                startSettling = true
-            }
-            lastPosition = value
-            if (startSettling) {
-                neighborsToSettle.setStartVelocity(velocity).animateToFinalPosition(0f)
-                playDismissSettlingHaptic(velocity)
-            }
-        }
+        addThresholdSpringAnimationTrigger(
+            springAnimationDriver,
+            progressThreshold = driverProgressThreshold,
+            neighborsToSettle,
+        )
 
         // Add tasks before dragged index, fanning out from the dragged task.
         // The order they are added matters, as each spring drives the next.
         var previousNeighbor = neighborsToSettle
-        getTasksOffsetPairAdjacentToDraggedTask(draggedTaskView, towardsStart = true).forEach {
-            (taskView, offset) ->
-            previousNeighbor =
-                createNeighboringTaskViewSpringAnimation(
-                    taskView,
-                    offset * ADDITIONAL_DISMISS_DAMPING_RATIO,
-                    previousNeighbor,
-                )
-        }
+        getTasksOffsetPairAdjacentToDraggedTask(draggedTaskView, towardsStart = true)
+            .filter { (taskView, _) -> !tasksToExclude.contains(taskView) }
+            .forEach { (taskView, offset) ->
+                previousNeighbor =
+                    createNeighboringTaskViewSpringAnimation(
+                        taskView,
+                        offset * ADDITIONAL_DISMISS_DAMPING_RATIO,
+                        previousNeighbor,
+                        isSpringDirectionVertical,
+                    )
+            }
         // Add tasks after dragged index, fanning out from the dragged task.
         // The order they are added matters, as each spring drives the next.
         previousNeighbor = neighborsToSettle
-        getTasksOffsetPairAdjacentToDraggedTask(draggedTaskView, towardsStart = false).forEach {
-            (taskView, offset) ->
-            previousNeighbor =
-                createNeighboringTaskViewSpringAnimation(
-                    taskView,
-                    offset * ADDITIONAL_DISMISS_DAMPING_RATIO,
-                    previousNeighbor,
-                )
+        getTasksOffsetPairAdjacentToDraggedTask(draggedTaskView, towardsStart = false)
+            .filter { (taskView, _) -> !tasksToExclude.contains(taskView) }
+            .forEach { (taskView, offset) ->
+                previousNeighbor =
+                    createNeighboringTaskViewSpringAnimation(
+                        taskView,
+                        offset * ADDITIONAL_DISMISS_DAMPING_RATIO,
+                        previousNeighbor,
+                        isSpringDirectionVertical,
+                    )
+            }
+    }
+
+    /** As spring passes threshold for the first time, run conditional spring with velocity. */
+    private fun addThresholdSpringAnimationTrigger(
+        springAnimationDriver: SpringAnimation,
+        progressThreshold: Float,
+        conditionalSpring: SpringAnimation,
+    ) {
+        var lastPosition = 0f
+        var startSettling = false
+        springAnimationDriver.addUpdateListener { _, value, velocity ->
+            // We do not compare to the threshold directly, as the update listener
+            // does not necessarily hit every value. Do not check again once it has started
+            // settling, as a spring can bounce past the end value multiple times.
+            if (startSettling) return@addUpdateListener
+            if (
+                lastPosition < progressThreshold && value >= progressThreshold ||
+                    lastPosition > progressThreshold && value <= progressThreshold
+            ) {
+                startSettling = true
+            }
+            lastPosition = value
+            if (startSettling) {
+                conditionalSpring.setStartVelocity(velocity).animateToFinalPosition(0f)
+                playDismissSettlingHaptic(velocity)
+            }
         }
     }
 
@@ -208,21 +233,25 @@
         taskView: TaskView,
         dampingOffsetRatio: Float,
         previousNeighborSpringAnimation: SpringAnimation,
+        springingDirectionVertical: Boolean,
     ): SpringAnimation {
+        val springProperty =
+            if (springingDirectionVertical) taskView.secondaryDismissTranslationProperty
+            else taskView.primaryDismissTranslationProperty
         val neighboringTaskViewSpringAnimation =
-            SpringAnimation(
-                    taskView,
-                    FloatPropertyCompat.createFloatPropertyCompat(
-                        taskView.secondaryDismissTranslationProperty
-                    ),
-                )
+            SpringAnimation(taskView, FloatPropertyCompat.createFloatPropertyCompat(springProperty))
                 .setSpring(createExpressiveDismissSpringForce(dampingOffsetRatio))
         // Update live tile on spring animation.
         if (taskView.isRunningTask && recentsView.enableDrawingLiveTile) {
             neighboringTaskViewSpringAnimation.addUpdateListener { _, _, _ ->
                 recentsView.runActionOnRemoteHandles { remoteTargetHandle ->
-                    remoteTargetHandle.taskViewSimulator.taskSecondaryTranslation.value =
-                        taskView.secondaryDismissTranslationProperty.get(taskView)
+                    val taskTranslation =
+                        if (springingDirectionVertical) {
+                            remoteTargetHandle.taskViewSimulator.taskSecondaryTranslation
+                        } else {
+                            remoteTargetHandle.taskViewSimulator.taskPrimaryTranslation
+                        }
+                    taskTranslation.value = springProperty.get(taskView)
                 }
                 recentsView.redrawLiveTile()
             }
@@ -268,10 +297,10 @@
         val maxDismissSettlingVelocity =
             recentsView.pagedOrientationHandler.getSecondaryDimension(recentsView)
         MSDLPlayerWrapper.INSTANCE.get(recentsView.context)
-            .playToken(
+            ?.playToken(
                 MSDLToken.CANCEL,
                 InteractionProperties.DynamicVibrationScale(
-                    boundToRange(velocity / maxDismissSettlingVelocity, 0f, 1f),
+                    boundToRange(abs(velocity) / maxDismissSettlingVelocity, 0f, 1f),
                     VibrationAttributes.Builder()
                         .setUsage(VibrationAttributes.USAGE_TOUCH)
                         .setFlags(VibrationAttributes.FLAG_PIPELINED_EFFECT)
@@ -312,6 +341,7 @@
     private fun runTaskGridReflowSpringAnimation(
         dismissedTaskView: TaskView,
         dismissedTaskGap: Float,
+        onEndRunnable: () -> Unit,
     ) {
         // Empty spring animation exists for conditional start, and to drive neighboring springs.
         val springAnimationDriver =
@@ -319,32 +349,39 @@
                 .setSpring(createExpressiveGridReflowSpringForce(finalPosition = dismissedTaskGap))
         val towardsStart = if (recentsView.isRtl) dismissedTaskGap < 0 else dismissedTaskGap > 0
 
+        var tasksToReflow: List<TaskView>
         // Build the chains of Spring Animations
         when {
             !recentsView.showAsGrid() -> {
-                buildDismissReflowSpringAnimationChain(
+                tasksToReflow =
                     getTasksToReflow(
                         recentsView.mUtils.taskViews.toList(),
                         dismissedTaskView,
                         towardsStart,
-                    ),
+                    )
+                buildDismissReflowSpringAnimationChain(
+                    tasksToReflow,
                     dismissedTaskGap,
                     previousSpring = springAnimationDriver,
                 )
             }
             dismissedTaskView.isLargeTile -> {
+                tasksToReflow =
+                    getTasksToReflow(
+                        recentsView.mUtils.getLargeTaskViews(),
+                        dismissedTaskView,
+                        towardsStart,
+                    )
                 val lastSpringAnimation =
                     buildDismissReflowSpringAnimationChain(
-                        getTasksToReflow(
-                            recentsView.mUtils.getLargeTaskViews(),
-                            dismissedTaskView,
-                            towardsStart,
-                        ),
+                        tasksToReflow,
                         dismissedTaskGap,
                         previousSpring = springAnimationDriver,
                     )
                 // Add all top and bottom grid tasks when animating towards the end of the grid.
                 if (!towardsStart) {
+                    tasksToReflow += recentsView.mUtils.getTopRowTaskViews()
+                    tasksToReflow += recentsView.mUtils.getBottomRowTaskViews()
                     buildDismissReflowSpringAnimationChain(
                         recentsView.mUtils.getTopRowTaskViews(),
                         dismissedTaskGap,
@@ -358,33 +395,52 @@
                 }
             }
             recentsView.isOnGridBottomRow(dismissedTaskView) -> {
-                buildDismissReflowSpringAnimationChain(
+                tasksToReflow =
                     getTasksToReflow(
                         recentsView.mUtils.getBottomRowTaskViews(),
                         dismissedTaskView,
                         towardsStart,
-                    ),
+                    )
+                buildDismissReflowSpringAnimationChain(
+                    tasksToReflow,
                     dismissedTaskGap,
                     previousSpring = springAnimationDriver,
                 )
             }
             else -> {
-                buildDismissReflowSpringAnimationChain(
+                tasksToReflow =
                     getTasksToReflow(
                         recentsView.mUtils.getTopRowTaskViews(),
                         dismissedTaskView,
                         towardsStart,
-                    ),
+                    )
+                buildDismissReflowSpringAnimationChain(
+                    tasksToReflow,
                     dismissedTaskGap,
                     previousSpring = springAnimationDriver,
                 )
             }
         }
 
+        if (tasksToReflow.isNotEmpty()) {
+            addNeighborSettlingSpringAnimations(
+                dismissedTaskView,
+                springAnimationDriver,
+                tasksToExclude = tasksToReflow,
+                driverProgressThreshold = dismissedTaskGap,
+                isSpringDirectionVertical = false,
+            )
+        } else {
+            springAnimationDriver.addEndListener { _, _, _, _ ->
+                // Play the same haptic as when neighbors spring into place.
+                MSDLPlayerWrapper.INSTANCE.get(recentsView.context)?.playToken(MSDLToken.CANCEL)
+            }
+        }
+
         // Start animations and remove the dismissed task at the end, dismiss immediately if no
         // neighboring tasks exist.
         val runGridEndAnimationAndRelayout = {
-            recentsView.expressiveDismissTaskView(dismissedTaskView)
+            recentsView.expressiveDismissTaskView(dismissedTaskView, onEndRunnable)
         }
         springAnimationDriver?.apply {
             addEndListener { _, _, _, _ -> runGridEndAnimationAndRelayout() }
@@ -429,8 +485,8 @@
                 else -> 1f
             } * (if (recentsView.isRtl) 1f else -1f)
 
-        return (dismissedTaskView.layoutParams.width + recentsView.pageSpacing) *
-            dismissHorizontalFactor
+        return (recentsView.pagedOrientationHandler.getPrimarySize(dismissedTaskView) +
+            recentsView.pageSpacing) * dismissHorizontalFactor
     }
 
     private fun getTasksToReflow(
diff --git a/quickstep/src/com/android/quickstep/views/RecentsView.java b/quickstep/src/com/android/quickstep/views/RecentsView.java
index bb2aa75..aa25738 100644
--- a/quickstep/src/com/android/quickstep/views/RecentsView.java
+++ b/quickstep/src/com/android/quickstep/views/RecentsView.java
@@ -17,6 +17,8 @@
 package com.android.quickstep.views;
 
 import static android.app.ActivityTaskManager.INVALID_TASK_ID;
+import static android.os.Trace.traceBegin;
+import static android.os.Trace.traceEnd;
 import static android.view.Surface.ROTATION_0;
 import static android.view.View.MeasureSpec.EXACTLY;
 import static android.view.View.MeasureSpec.makeMeasureSpec;
@@ -32,14 +34,13 @@
 import static com.android.app.animation.Interpolators.LINEAR;
 import static com.android.app.animation.Interpolators.clampToProgress;
 import static com.android.launcher3.AbstractFloatingView.TYPE_REBIND_SAFE;
-import static com.android.launcher3.AbstractFloatingView.TYPE_TASK_MENU;
-import static com.android.launcher3.AbstractFloatingView.getTopOpenViewWithType;
 import static com.android.launcher3.BaseActivity.STATE_HANDLER_INVISIBILITY_FLAGS;
 import static com.android.launcher3.Flags.enableAdditionalHomeAnimations;
 import static com.android.launcher3.Flags.enableDesktopExplodedView;
 import static com.android.launcher3.Flags.enableDesktopTaskAlphaAnimation;
 import static com.android.launcher3.Flags.enableGridOnlyOverview;
 import static com.android.launcher3.Flags.enableLargeDesktopWindowingTile;
+import static com.android.launcher3.Flags.enableOverviewBackgroundWallpaperBlur;
 import static com.android.launcher3.Flags.enableRefactorTaskThumbnail;
 import static com.android.launcher3.Flags.enableSeparateExternalDisplayTasks;
 import static com.android.launcher3.LauncherAnimUtils.SUCCESS_TRANSITION_PROGRESS;
@@ -56,6 +57,7 @@
 import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_TASK_CLEAR_ALL;
 import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_TASK_DISMISS_SWIPE_UP;
 import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_TASK_LAUNCH_SWIPE_DOWN;
+import static com.android.launcher3.statehandlers.DesktopVisibilityController.INACTIVE_DESK_ID;
 import static com.android.launcher3.testing.shared.TestProtocol.DISMISS_ANIMATION_ENDS_MESSAGE;
 import static com.android.launcher3.touch.PagedOrientationHandler.CANVAS_TRANSLATE;
 import static com.android.launcher3.util.Executors.MAIN_EXECUTOR;
@@ -64,6 +66,7 @@
 import static com.android.launcher3.util.SystemUiController.UI_STATE_FULLSCREEN_TASK;
 import static com.android.quickstep.BaseContainerInterface.getTaskDimension;
 import static com.android.quickstep.TaskUtils.checkCurrentOrManagedUserId;
+import static com.android.quickstep.util.DesksUtils.areMultiDesksFlagsEnabled;
 import static com.android.quickstep.util.LogUtils.splitFailureMessage;
 import static com.android.quickstep.views.ClearAllButton.DISMISS_ALPHA;
 import static com.android.quickstep.views.OverviewActionsView.HIDDEN_ACTIONS_IN_MENU;
@@ -102,6 +105,7 @@
 import android.graphics.drawable.Drawable;
 import android.os.Bundle;
 import android.os.SystemClock;
+import android.os.Trace;
 import android.os.UserHandle;
 import android.os.VibrationEffect;
 import android.text.Layout;
@@ -212,7 +216,6 @@
 import com.android.quickstep.recents.viewmodel.RecentsViewModel;
 import com.android.quickstep.util.ActiveGestureProtoLogProxy;
 import com.android.quickstep.util.AnimUtils;
-import com.android.quickstep.util.DesksUtils;
 import com.android.quickstep.util.DesktopTask;
 import com.android.quickstep.util.GroupTask;
 import com.android.quickstep.util.LayoutUtils;
@@ -272,7 +275,7 @@
         HighResLoadingState.HighResLoadingStateChangedCallback,
         TaskVisualsChangeListener, DesktopVisibilityListener {
 
-    private static final String TAG = "RecentsView";
+    protected static final String TAG = "RecentsView";
     private static final boolean DEBUG = false;
 
     public static final FloatProperty<RecentsView<?, ?>> CONTENT_ALPHA =
@@ -531,7 +534,6 @@
     protected final Rect mLastComputedTaskSize = new Rect();
     protected final Rect mLastComputedGridSize = new Rect();
     protected final Rect mLastComputedGridTaskSize = new Rect();
-    private TaskView mSelectedTask = null;
     // How much a task that is directly offscreen will be pushed out due to RecentsView scale/pivot.
     @Nullable
     protected Float mLastComputedTaskStartPushOutDistance = null;
@@ -584,6 +586,8 @@
     private final TaskOverlayFactory mTaskOverlayFactory;
 
     protected boolean mDisallowScrollToClearAll;
+    // True if it is not allowed to scroll to [AddDesktopButton].
+    protected boolean mDisallowScrollToAddDesk;
     private boolean mOverlayEnabled;
     protected boolean mFreezeViewVisibility;
     private boolean mOverviewGridEnabled;
@@ -827,7 +831,7 @@
                     mOrientationState.setMultiWindowMode(inMultiWindowMode);
                     setLayoutRotation(mOrientationState.getTouchRotation(),
                             mOrientationState.getDisplayRotation());
-                    updateChildTaskOrientations();
+                    mUtils.updateChildTaskOrientations();
                     if (!inMultiWindowMode && mOverviewStateEnabled) {
                         // TODO: Re-enable layout transitions for addition of the unpinned task
                         reloadIfNeeded();
@@ -863,6 +867,9 @@
     private final Matrix mTmpMatrix = new Matrix();
 
     private int mTaskViewCount = 0;
+
+    protected final BlurUtils mBlurUtils = new BlurUtils(this);
+
     @Nullable
     public TaskView getFirstTaskView() {
         return mUtils.getFirstTaskView();
@@ -1291,6 +1298,7 @@
 
     @Override
     public void onViewRemoved(View child) {
+        traceBegin(Trace.TRACE_TAG_APP, "RecentsView.onViewRemoved");
         super.onViewRemoved(child);
         // Clear the task data for the removed child if it was visible unless:
         // - It's the initial taskview for entering split screen, we only pretend to dismiss the
@@ -1302,6 +1310,7 @@
                 clearAndRecycleTaskView((TaskView) child);
             }
         }
+        traceEnd(Trace.TRACE_TAG_APP);
     }
 
     private void clearAndRecycleTaskView(TaskView taskView) {
@@ -1320,6 +1329,7 @@
 
     @Override
     public void onViewAdded(View child) {
+        traceBegin(Trace.TRACE_TAG_APP, "RecentsView.onViewAdded");
         super.onViewAdded(child);
         if (child instanceof TaskView) {
             mTaskViewCount++;
@@ -1330,6 +1340,7 @@
         child.setLayoutDirection(mIsRtl ? View.LAYOUT_DIRECTION_LTR : View.LAYOUT_DIRECTION_RTL);
         mActionsView.updateHiddenFlags(HIDDEN_NO_TASKS, false);
         updateEmptyMessage();
+        traceEnd(Trace.TRACE_TAG_APP);
     }
 
     @Override
@@ -1926,14 +1937,19 @@
             return;
         }
 
-        // TODO: b/400532675 - The use of `currentTaskIds`, `runningTaskIds`, and `focusedTaskIds`
-        // needs to be audited so that they can work with empty desks that have no tasks.
-        int[] currentTaskIds;
+        // Start here to avoid early returns and empty cases which have special logic
+        traceBegin(Trace.TRACE_TAG_APP, "RecentsView.applyLoadPlan");
+
         TaskView currentTaskView = getTaskViewAt(mCurrentPage);
-        if (currentTaskView != null) {
+        int[] currentTaskIds = null;
+        // Track the current DesktopTaskView through [deskId] as a desk can be empty without any
+        // tasks.
+        int currentTaskViewDeskId = INACTIVE_DESK_ID;
+        if (areMultiDesksFlagsEnabled()
+                && currentTaskView instanceof DesktopTaskView desktopTaskView) {
+            currentTaskViewDeskId = desktopTaskView.getDeskId();
+        } else if (currentTaskView != null) {
             currentTaskIds = currentTaskView.getTaskIds();
-        } else {
-            currentTaskIds = new int[0];
         }
 
         // Unload existing visible task data
@@ -1945,9 +1961,19 @@
 
         // Save running task ID if it exists before rebinding all taskViews, otherwise the task from
         // the runningTaskView currently bound could get assigned to another TaskView
-        int[] runningTaskIds = getTaskIdsForTaskViewId(mRunningTaskViewId);
-        int[] focusedTaskIds = getTaskIdsForTaskViewId(mFocusedTaskViewId);
+        TaskView runningTaskView = getRunningTaskView();
+        int[] runningTaskIds = null;
 
+        // Track the running TaskView through [deskId] as a desk can be empty without any tasks.
+        int runningTaskViewDeskId = INACTIVE_DESK_ID;
+        if (areMultiDesksFlagsEnabled()
+                && runningTaskView instanceof DesktopTaskView desktopTaskView) {
+            runningTaskViewDeskId = desktopTaskView.getDeskId();
+        } else if (runningTaskView != null) {
+            runningTaskIds = runningTaskView.getTaskIds();
+        }
+
+        int[] focusedTaskIds = getTaskIdsForTaskViewId(mFocusedTaskViewId);
         // Reset the focused task to avoiding initializing TaskViews layout as focused task during
         // binding. The focused task view will be updated after all the TaskViews are bound.
         setFocusedTaskViewId(INVALID_TASK_ID);
@@ -1959,8 +1985,9 @@
         // TaskIds will no longer be valid after remove and re-add, clearing mTopRowIdSet.
         mAnyTaskHasBeenDismissed = false;
         mTopRowIdSet.clear();
+        traceBegin(Trace.TRACE_TAG_APP, "RecentsView.applyLoadPlan.removeAllViews");
         removeAllViews();
-
+        traceEnd(Trace.TRACE_TAG_APP);
         // If we are entering Overview as a result of initiating a split from somewhere else
         // (e.g. split from Home), we need to make sure the staged app is not drawn as a thumbnail.
         int stagedTaskIdToBeRemoved;
@@ -1987,6 +2014,7 @@
             // Add `mAddDesktopButton` as the first child.
             addView(mAddDesktopButton);
         }
+        traceBegin(Trace.TRACE_TAG_APP, "RecentsView.applyLoadPlan.forLoop");
 
         // Add views as children based on whether it's grouped or single task. Looping through
         // taskGroups backwards populates the thumbnail grid from least recent to most recent.
@@ -2006,8 +2034,11 @@
 
             // If we need to remove half of a pair of tasks, force a TaskView with Type.SINGLE
             // to be a temporary container for the remaining task.
+            traceBegin(Trace.TRACE_TAG_APP, "RecentsView.applyLoadPlan.forLoop.createTaskView");
             TaskView taskView = getTaskViewFromPool(
                     containsStagedTask ? TaskViewType.SINGLE : groupTask.taskViewType);
+            traceEnd(Trace.TRACE_TAG_APP);
+            traceBegin(Trace.TRACE_TAG_APP, "RecentsView.applyLoadPlan.forLoop.bind");
             if (taskView instanceof GroupedTaskView groupedTaskView) {
                 var splitTask = (SplitTask) groupTask;
                 groupedTaskView.bind(splitTask.getTopLeftTask(),
@@ -2025,13 +2056,18 @@
                 taskView.bind(((SingleTask) groupTask).getTask(), mOrientationState,
                         mTaskOverlayFactory);
             }
+            traceEnd(Trace.TRACE_TAG_APP);
+            traceBegin(Trace.TRACE_TAG_APP, "RecentsView.applyLoadPlan.forLoop.addTaskView");
             addView(taskView);
+            traceEnd(Trace.TRACE_TAG_APP);
 
             // enables instance filtering if the feature flag for it is on
             if (FeatureFlags.ENABLE_MULTI_INSTANCE.get()) {
                 taskView.setUpShowAllInstancesListener();
             }
         }
+        // For loop end trace
+        traceEnd(Trace.TRACE_TAG_APP);
 
         addView(mClearAllButton);
 
@@ -2051,27 +2087,29 @@
         setFocusedTaskViewId(
                 newFocusedTaskView != null ? newFocusedTaskView.getTaskViewId() : INVALID_TASK_ID);
 
+        traceBegin(Trace.TRACE_TAG_APP, "RecentsView.applyLoadPlan.layouts");
         updateTaskSize();
-        updateChildTaskOrientations();
+        mUtils.updateChildTaskOrientations();
+        traceEnd(Trace.TRACE_TAG_APP);
 
-        TaskView newRunningTaskView = null;
-        if (hasAllValidTaskIds(runningTaskIds)) {
+        TaskView newRunningTaskView = mUtils.getDesktopTaskViewForDeskId(runningTaskViewDeskId);
+        if (newRunningTaskView == null) {
             // Update mRunningTaskViewId to be the new TaskView that was assigned by binding
             // the full list of tasks to taskViews
             newRunningTaskView = getTaskViewByTaskIds(runningTaskIds);
-            if (newRunningTaskView != null) {
-                setRunningTaskViewId(newRunningTaskView.getTaskViewId());
+        }
+        if (newRunningTaskView != null) {
+            setRunningTaskViewId(newRunningTaskView.getTaskViewId());
+        } else {
+            if (mActiveGestureRunningTasks != null) {
+                // This will update mRunningTaskViewId and create a stub view if necessary.
+                // We try to avoid this because it can cause a scroll jump, but it is needed
+                // for cases where the running task isn't included in this load plan (e.g. if
+                // the current running task is excludedFromRecents.)
+                showCurrentTask(mActiveGestureRunningTasks, "applyLoadPlan");
+                newRunningTaskView = getRunningTaskView();
             } else {
-                if (mActiveGestureRunningTasks != null) {
-                    // This will update mRunningTaskViewId and create a stub view if necessary.
-                    // We try to avoid this because it can cause a scroll jump, but it is needed
-                    // for cases where the running task isn't included in this load plan (e.g. if
-                    // the current running task is excludedFromRecents.)
-                    showCurrentTask(mActiveGestureRunningTasks, "applyLoadPlan");
-                    newRunningTaskView = getRunningTaskView();
-                } else {
-                    setRunningTaskViewId(INVALID_TASK_ID);
-                }
+                setRunningTaskViewId(INVALID_TASK_ID);
             }
         }
 
@@ -2079,11 +2117,12 @@
         if (mNextPage != INVALID_PAGE) {
             // Restore mCurrentPage but don't call setCurrentPage() as that clobbers the scroll.
             mCurrentPage = previousCurrentPage;
-            if (hasAllValidTaskIds(currentTaskIds)) {
+            currentTaskView = mUtils.getDesktopTaskViewForDeskId(currentTaskViewDeskId);
+            if (currentTaskView == null) {
                 currentTaskView = getTaskViewByTaskIds(currentTaskIds);
-                if (currentTaskView != null) {
-                    targetPage = indexOfChild(currentTaskView);
-                }
+            }
+            if (currentTaskView != null) {
+                targetPage = indexOfChild(currentTaskView);
             }
         } else if (previousFocusedPage != INVALID_PAGE) {
             targetPage = previousFocusedPage;
@@ -2106,6 +2145,7 @@
             });
         }
 
+        traceBegin(Trace.TRACE_TAG_APP, "RecentsView.applyLoadPlan.cleanupStates");
         if (mIgnoreResetTaskId != INVALID_TASK_ID &&
                 getTaskViewByTaskId(mIgnoreResetTaskId) != ignoreResetTaskView) {
             // If the taskView mapping is changing, do not preserve the visuals. Since we are
@@ -2120,6 +2160,10 @@
         if (isPageScrollsInitialized()) {
             onPageScrollsInitialized();
         }
+        traceEnd(Trace.TRACE_TAG_APP);
+
+        // applyLoadPlan end trace
+        traceEnd(Trace.TRACE_TAG_APP);
     }
 
     private boolean isModal() {
@@ -2297,7 +2341,7 @@
         updateSizeAndPadding();
 
         // Update TaskView's DeviceProfile dependent layout.
-        updateChildTaskOrientations();
+        mUtils.updateChildTaskOrientations();
 
         requestLayout();
         // Reapply the current page to update page scrolls.
@@ -2373,21 +2417,28 @@
     }
 
     /**
-     * Sets the last TaskView selected.
+     * Returns the currently selected TaskView in Select mode.
+     */
+    @Nullable
+    public TaskView getSelectedTaskView() {
+        return mUtils.getSelectedTaskView();
+    }
+
+    /**
+     * Sets the selected TaskView in Select mode.
      */
     public void setSelectedTask(int lastSelectedTaskId) {
-        mSelectedTask = getTaskViewByTaskId(lastSelectedTaskId);
+        mUtils.setSelectedTaskView(getTaskViewByTaskId(lastSelectedTaskId));
     }
 
     /**
      * Returns the bounds of the task selected to enter modal state.
      */
     public Rect getSelectedTaskBounds() {
-        if (mSelectedTask == null) {
-            return enableGridOnlyOverview() && mContainer.getDeviceProfile().isTablet
-                    ? mLastComputedGridTaskSize : mLastComputedTaskSize;
+        if (getSelectedTaskView() == null) {
+            return mLastComputedTaskSize;
         }
-        return getTaskBounds(mSelectedTask);
+        return getTaskBounds(getSelectedTaskView());
     }
 
     /**
@@ -2403,7 +2454,7 @@
         return deviceProfile.overviewTaskThumbnailTopMarginPx / 2.0f;
     }
 
-    private Rect getTaskBounds(TaskView taskView) {
+    protected Rect getTaskBounds(TaskView taskView) {
         int selectedPage = indexOfChild(taskView);
         int primaryScroll = getPagedOrientationHandler().getPrimaryScroll(this);
         int selectedPageScroll = getScrollForPage(selectedPage);
@@ -2705,9 +2756,7 @@
             }
             setEnableDrawingLiveTile(false);
         }
-        runActionOnRemoteHandles(remoteTargetHandle ->
-                remoteTargetHandle.getTaskViewSimulator().setDrawsBelowRecents(false));
-
+        mBlurUtils.setDrawLiveTileBelowRecents(false);
         // These are relatively expensive and don't need to be done this frame (RecentsView isn't
         // visible anyway), so defer by a frame to get off the critical path, e.g. app to home.
         post(this::onReset);
@@ -2907,22 +2956,6 @@
         return as;
     }
 
-    private void updateChildTaskOrientations() {
-        for (TaskView taskView : getTaskViews()) {
-            taskView.setOrientationState(mOrientationState);
-        }
-        boolean shouldRotateMenuForFakeRotation =
-                !mOrientationState.isRecentsActivityRotationAllowed();
-        if (!shouldRotateMenuForFakeRotation) {
-            return;
-        }
-        AbstractFloatingView floatingView = getTopOpenViewWithType(mContainer, TYPE_TASK_MENU);
-        if (floatingView instanceof TaskMenuView taskMenuView) {
-            // Rotation is supported on phone (details at b/254198019#comment4)
-            taskMenuView.onRotationChanged();
-        }
-    }
-
     /**
      * Called when a gesture from an app has finished, and an end target has been determined.
      */
@@ -3079,7 +3112,8 @@
 
         // TODO: b/401582344 - Implement a way to exclude the `DesktopWallpaperActivity`.
         desktopTaskView.bind(
-                new DesktopTask(activeDeskId, Arrays.asList(runningTasks)),
+                new DesktopTask(activeDeskId, mContainer.getDisplayId(),
+                        Arrays.asList(runningTasks)),
                 mOrientationState, mTaskOverlayFactory);
         return desktopTaskView;
     }
@@ -3159,7 +3193,7 @@
         setRunningTaskHidden(runningTaskTileHidden);
         // Update task size after setting current task.
         updateTaskSize();
-        updateChildTaskOrientations();
+        mUtils.updateChildTaskOrientations();
 
         // Reload the task list
         reloadIfNeeded();
@@ -3909,7 +3943,7 @@
                 newClearAllShortTotalWidthTranslation = expectedFirstTaskStart - firstTaskStart;
             }
         }
-        if (lastGridTaskView != null && (lastGridTaskView.isVisibleToUser() || (
+        if (lastGridTaskView != null && (isTaskViewVisible(lastGridTaskView) || (
                 isExpressiveDismiss && lastGridTaskView == dismissedTaskView))) {
             // After dismissal, animate translation of the remaining tasks to fill any gap left
             // between the end of the grid and the clear all button. Only animate if the clear
@@ -4312,7 +4346,7 @@
                             finalNextFocusedTaskView.getDismissIconFadeInAnimator().start();
                         }
                         updateTaskSize();
-                        updateChildTaskOrientations();
+                        mUtils.updateChildTaskOrientations();
                         // Update scroll and snap to page.
                         updateScrollSynchronously();
 
@@ -4565,7 +4599,7 @@
     }
 
     private void removeDesktopTaskView(DesktopTaskView desktopTaskView) {
-        if (DesksUtils.areMultiDesksFlagsEnabled()) {
+        if (areMultiDesksFlagsEnabled()) {
             SystemUiProxy.INSTANCE
                     .get(getContext())
                     .removeDesk(desktopTaskView.getDeskId());
@@ -4706,11 +4740,12 @@
         runDismissAnimation(pa);
     }
 
-    protected void expressiveDismissTaskView(TaskView taskView) {
+    protected void expressiveDismissTaskView(TaskView taskView, Function0<Unit> onEndRunnable) {
         PendingAnimation pa = new PendingAnimation(DISMISS_TASK_DURATION);
         createTaskDismissAnimation(pa, taskView, false /* animateTaskView */, true /* removeTask */,
                 DISMISS_TASK_DURATION, false /* dismissingForSplitSelection*/,
                 true /* isExpressiveDismiss */);
+        pa.addEndListener((success) -> onEndRunnable.invoke());
         runDismissAnimation(pa);
     }
 
@@ -4738,6 +4773,11 @@
         if (isHandlingTouch() || event.getAction() != KeyEvent.ACTION_DOWN) {
             return super.dispatchKeyEvent(event);
         }
+
+        if (mUtils.shouldInterceptKeyEvent(event)) {
+            return super.dispatchKeyEvent(event);
+        }
+
         switch (event.getKeyCode()) {
             case KeyEvent.KEYCODE_TAB:
                 return snapToPageRelative(event.isShiftPressed() ? -1 : 1, true /* cycle */,
@@ -4978,15 +5018,8 @@
     }
 
     private void updatePivots() {
-        if (mOverviewSelectEnabled) {
-            if (enableGridOnlyOverview()) {
-                getModalTaskSize(mTempRect);
-                Rect selectedTaskPosition = getSelectedTaskBounds();
-                Utilities.getPivotsForScalingRectToRect(mTempRect, selectedTaskPosition,
-                        mTempPointF);
-            } else {
-                mTempPointF.set(mLastComputedTaskSize.centerX(), mLastComputedTaskSize.bottom);
-            }
+        if (mOverviewSelectEnabled && !enableGridOnlyOverview()) {
+            mTempPointF.set(mLastComputedTaskSize.centerX(), mLastComputedTaskSize.bottom);
         } else {
             mTempRect.set(mLastComputedTaskSize);
             getPagedViewOrientedState().getFullScreenScaleAndPivot(mTempRect,
@@ -5032,7 +5065,7 @@
                 && (enableGridOnlyOverview() || enableLargeDesktopWindowingTile())
                 && mTaskModalness > 0;
         if (shouldCalculateOffsetForAllTasks) {
-            modalMidpoint = indexOfChild(mSelectedTask);
+            modalMidpoint = indexOfChild(getSelectedTaskView());
         }
 
         float midpointOffsetSize = 0;
@@ -5240,7 +5273,7 @@
      */
     private float getVerticalOffsetSize(TaskView taskView, float offsetProgress) {
         if (offsetProgress == 0 || !(showAsGrid() && enableGridOnlyOverview())
-                || mSelectedTask == null) {
+                || getSelectedTaskView() == null) {
             // Don't bother calculating everything below if we won't offset vertically.
             return 0;
         }
@@ -5248,7 +5281,7 @@
         // First, get the position of the task relative to the top row.
         Rect taskPosition = getTaskBounds(taskView);
 
-        boolean isSelectedTaskTopRow = mTopRowIdSet.contains(mSelectedTask.getTaskViewId());
+        boolean isSelectedTaskTopRow = mTopRowIdSet.contains(getSelectedTaskView().getTaskViewId());
         boolean isChildTopRow = mTopRowIdSet.contains(taskView.getTaskViewId());
         // Whether the task should be shifted to the top.
         boolean isTopShift = !isSelectedTaskTopRow && isChildTopRow;
@@ -5302,8 +5335,8 @@
      * Resets the visuals when exit modal state.
      */
     public void resetModalVisuals() {
-        if (mSelectedTask != null) {
-            mSelectedTask.taskContainers.forEach(
+        if (getSelectedTaskView() != null) {
+            getSelectedTaskView().taskContainers.forEach(
                     taskContainer -> taskContainer.getOverlay().resetModalVisuals());
         }
     }
@@ -5772,12 +5805,10 @@
                     // above RecentsView to avoid wallpaper blur from being applied to it.
                     if (!taskView.isRunningTask()) {
                         runActionOnRemoteHandles(
-                                remoteTargetHandle -> {
-                                    remoteTargetHandle.getTaskViewSimulator().setPivotOverride(
-                                            mTempPointF);
-                                    remoteTargetHandle.getTaskViewSimulator().setDrawsBelowRecents(
-                                            false);
-                                });
+                                remoteTargetHandle ->
+                                        remoteTargetHandle.getTaskViewSimulator()
+                                                .setPivotOverride(mTempPointF));
+                        mBlurUtils.setDrawLiveTileBelowRecents(false);
                     }
                 }
 
@@ -5912,8 +5943,7 @@
         mPendingAnimation.addListener(new AnimatorListenerAdapter() {
             @Override
             public void onAnimationStart(Animator animation) {
-                runActionOnRemoteHandles(remoteTargetHandle ->
-                        remoteTargetHandle.getTaskViewSimulator().setDrawsBelowRecents(false));
+                mBlurUtils.setDrawLiveTileBelowRecents(false);
             }
         });
         mPendingAnimation.addEndListener(isSuccess -> {
@@ -5951,8 +5981,7 @@
             // If launch animation didn't complete i.e. user dragged live tile down and then
             // back up and returned to Overview, then we need to ensure we reset the
             // view to draw below recents so that it can't be interacted with.
-            runActionOnRemoteHandles(remoteTargetHandle ->
-                    remoteTargetHandle.getTaskViewSimulator().setDrawsBelowRecents(true));
+            mBlurUtils.setDrawLiveTileBelowRecents(true);
             redrawLiveTile();
         }
         return Unit.INSTANCE;
@@ -6031,6 +6060,7 @@
         });
     }
 
+    @Nullable
     public RemoteTargetHandle[] getRemoteTargetHandles() {
         return mRemoteTargetHandles;
     }
@@ -6184,6 +6214,9 @@
         mRecentsAnimationController = null;
         mSplitSelectStateController.setRecentsAnimationRunning(false);
         executeSideTaskLaunchCallback();
+        if (enableOverviewBackgroundWallpaperBlur()) {
+            mBlurUtils.setDrawLiveTileBelowRecents(false);
+        }
     }
 
     public void setDisallowScrollToClearAll(boolean disallowScrollToClearAll) {
@@ -6192,6 +6225,17 @@
             updateMinAndMaxScrollX();
         }
     }
+    /**
+     * Update the value of [mDisallowScrollToAddDesk]
+     */
+    public void setDisallowScrollToAddDesk(boolean disallowScrollToAddDesk) {
+        if (mDisallowScrollToAddDesk != disallowScrollToAddDesk) {
+            mDisallowScrollToAddDesk = disallowScrollToAddDesk;
+            updateMinAndMaxScrollX();
+        }
+    }
+
+
 
     /**
      * Updates page scroll synchronously after measure and layout child views.
@@ -6337,7 +6381,20 @@
         if (addDesktopButtonIndex >= 0 && addDesktopButtonIndex < outPageScrolls.length) {
             int firstViewIndex = getFirstViewIndex();
             if (firstViewIndex >= 0 && firstViewIndex < outPageScrolls.length) {
-                outPageScrolls[addDesktopButtonIndex] = outPageScrolls[firstViewIndex];
+                // If we can scroll to [AddDesktopButton], make its page scroll equal to
+                // the first [TaskView]. Otherwise, make its page scroll out of range of
+                // [minScroll, maxScroll].
+                if (!mDisallowScrollToAddDesk) {
+                    outPageScrolls[addDesktopButtonIndex] = outPageScrolls[firstViewIndex];
+                } else {
+                    outPageScrolls[addDesktopButtonIndex] =
+                            outPageScrolls[firstViewIndex] + (mIsRtl ? 1 : -1);
+                }
+            }
+
+            if (DEBUG) {
+                Log.d(TAG, "getPageScrolls - addDesktopButtonScroll: "
+                        + outPageScrolls[addDesktopButtonIndex]);
             }
         }
         if (DEBUG) {
@@ -6660,8 +6717,14 @@
     private void setTaskModalness(float modalness) {
         mTaskModalness = modalness;
         updatePageOffsets();
-        if (mSelectedTask != null) {
-            mSelectedTask.setModalness(modalness);
+        if (getSelectedTaskView() != null) {
+            if (enableGridOnlyOverview()) {
+                for (TaskView taskView : getTaskViews()) {
+                    taskView.setModalness(modalness);
+                }
+            } else {
+                getSelectedTaskView().setModalness(modalness);
+            }
         } else if (getCurrentPageTaskView() != null) {
             getCurrentPageTaskView().setModalness(modalness);
         }
@@ -6979,7 +7042,7 @@
         // `AddNewDesktopButton`.
         DesktopTaskView desktopTaskView =
                 (DesktopTaskView) getTaskViewFromPool(TaskViewType.DESKTOP);
-        desktopTaskView.bind(new DesktopTask(deskId, new ArrayList<>()),
+        desktopTaskView.bind(new DesktopTask(deskId, displayId, new ArrayList<>()),
                 mOrientationState, mTaskOverlayFactory);
 
         Objects.requireNonNull(mAddDesktopButton);
@@ -6987,7 +7050,7 @@
         addView(desktopTaskView, insertionIndex);
 
         updateTaskSize();
-        updateChildTaskOrientations();
+        mUtils.updateChildTaskOrientations();
 
         // TODO: b/401002178 - Recalculate the new current page such that the addition of the new
         //  desk does not result in a change in the current scroll page.
@@ -7139,4 +7202,15 @@
     public interface TaskLaunchListener {
         void onTaskLaunched();
     }
+
+    /**
+     * Sets whether the remote animation targets should draw below the recents view.
+     *
+     * @param drawBelowRecents  whether the surface should draw below Recents.
+     * @param remoteTargetHandles collection of remoteTargetHandles in Recents.
+     */
+    public void setDrawBelowRecents(boolean drawBelowRecents,
+            RemoteTargetHandle[] remoteTargetHandles) {
+        mBlurUtils.setDrawBelowRecents(drawBelowRecents, remoteTargetHandles);
+    }
 }
diff --git a/quickstep/src/com/android/quickstep/views/RecentsViewUtils.kt b/quickstep/src/com/android/quickstep/views/RecentsViewUtils.kt
index 037bef6..51a5d0f 100644
--- a/quickstep/src/com/android/quickstep/views/RecentsViewUtils.kt
+++ b/quickstep/src/com/android/quickstep/views/RecentsViewUtils.kt
@@ -16,22 +16,32 @@
 
 package com.android.quickstep.views
 
+import android.graphics.PointF
 import android.graphics.Rect
 import android.util.FloatProperty
+import android.view.KeyEvent
 import android.view.View
+import android.view.View.LAYOUT_DIRECTION_LTR
+import android.view.View.LAYOUT_DIRECTION_RTL
 import androidx.core.view.children
+import com.android.launcher3.AbstractFloatingView.TYPE_TASK_MENU
+import com.android.launcher3.AbstractFloatingView.getTopOpenViewWithType
+import com.android.launcher3.Flags.enableGridOnlyOverview
 import com.android.launcher3.Flags.enableLargeDesktopWindowingTile
+import com.android.launcher3.Flags.enableOverviewIconMenu
 import com.android.launcher3.Flags.enableSeparateExternalDisplayTasks
+import com.android.launcher3.Utilities.getPivotsForScalingRectToRect
 import com.android.launcher3.statehandlers.DesktopVisibilityController
 import com.android.launcher3.statehandlers.DesktopVisibilityController.Companion.INACTIVE_DESK_ID
 import com.android.launcher3.util.IntArray
-import com.android.quickstep.util.DesksUtils
+import com.android.quickstep.util.DesksUtils.Companion.areMultiDesksFlagsEnabled
 import com.android.quickstep.util.DesktopTask
 import com.android.quickstep.util.GroupTask
 import com.android.quickstep.util.isExternalDisplay
 import com.android.quickstep.views.RecentsView.RUNNING_TASK_ATTACH_ALPHA
 import com.android.systemui.shared.recents.model.ThumbnailData
 import java.util.function.BiConsumer
+import kotlin.math.min
 import kotlin.reflect.KMutableProperty1
 
 /**
@@ -57,7 +67,7 @@
      */
     fun sortDesktopTasksToFront(tasks: List<GroupTask>): List<GroupTask> {
         var (desktopTasks, otherTasks) = tasks.partition { it.taskViewType == TaskViewType.DESKTOP }
-        if (DesksUtils.areMultiDesksFlagsEnabled()) {
+        if (areMultiDesksFlagsEnabled()) {
             // Desk IDs of newer desks are larger than those of older desks, hence we can use them
             // to sort desks from old to new.
             desktopTasks = desktopTasks.sortedBy { (it as DesktopTask).deskId }
@@ -165,6 +175,17 @@
     private fun getDeviceProfile() = (recentsView.mContainer as RecentsViewContainer).deviceProfile
 
     fun getRunningTaskExpectedIndex(runningTaskView: TaskView): Int {
+        if (areMultiDesksFlagsEnabled() && runningTaskView is DesktopTaskView) {
+            // Use the [deskId] to keep desks in the order of their creation, as a newer desk
+            // always has a larger [deskId] than the older desks.
+            val desktopTaskView =
+                taskViews.firstOrNull {
+                    it is DesktopTaskView &&
+                        it.deskId != INACTIVE_DESK_ID &&
+                        it.deskId <= runningTaskView.deskId
+                }
+            if (desktopTaskView != null) return recentsView.indexOfChild(desktopTaskView)
+        }
         val firstTaskViewIndex = recentsView.indexOfChild(getFirstTaskView())
         return if (getDeviceProfile().isTablet) {
             var index = firstTaskViewIndex
@@ -343,12 +364,80 @@
         }
     }
 
+    private fun getTaskMenu(): TaskMenuView? =
+        getTopOpenViewWithType(recentsView.mContainer, TYPE_TASK_MENU) as? TaskMenuView
+
+    fun shouldInterceptKeyEvent(event: KeyEvent): Boolean {
+        if (enableOverviewIconMenu()) {
+            return getTaskMenu()?.isOpen == true || event.keyCode == KeyEvent.KEYCODE_TAB
+        }
+        return false
+    }
+
+    fun updateChildTaskOrientations() {
+        with(recentsView) {
+            taskViews.forEach { it.setOrientationState(mOrientationState) }
+            if (enableOverviewIconMenu()) {
+                children.forEach {
+                    it.layoutDirection = if (isRtl) LAYOUT_DIRECTION_LTR else LAYOUT_DIRECTION_RTL
+                }
+            }
+
+            // Return when it's not fake landscape
+            if (mOrientationState.isRecentsActivityRotationAllowed) return@with
+
+            // Rotation is supported on phone (details at b/254198019#comment4)
+            getTaskMenu()?.onRotationChanged()
+        }
+    }
+
     var deskExplodeProgress: Float = 0f
         set(value) {
             field = value
             taskViews.filterIsInstance<DesktopTaskView>().forEach { it.explodeProgress = field }
         }
 
+    var selectedTaskView: TaskView? = null
+        set(newValue) {
+            val oldValue = field
+            field = newValue
+            if (oldValue != newValue) {
+                onSelectedTaskViewUpdated(oldValue, newValue)
+            }
+        }
+
+    private fun onSelectedTaskViewUpdated(
+        oldSelectedTaskView: TaskView?,
+        newSelectedTaskView: TaskView?,
+    ) {
+        if (!enableGridOnlyOverview()) return
+        with(recentsView) {
+            oldSelectedTaskView?.modalScale = 1f
+            oldSelectedTaskView?.modalPivot = null
+
+            if (newSelectedTaskView == null) return
+
+            val modalTaskBounds = mTempRect
+            getModalTaskSize(modalTaskBounds)
+            val selectedTaskBounds = getTaskBounds(newSelectedTaskView)
+
+            // Map bounds to selectedTaskView's coordinate system.
+            modalTaskBounds.offset(-selectedTaskBounds.left, -selectedTaskBounds.top)
+            selectedTaskBounds.offset(-selectedTaskBounds.left, -selectedTaskBounds.top)
+
+            val modalScale =
+                min(
+                    (modalTaskBounds.height().toFloat() / selectedTaskBounds.height()),
+                    (modalTaskBounds.width().toFloat() / selectedTaskBounds.width()),
+                )
+            val modalPivot = PointF()
+            getPivotsForScalingRectToRect(modalTaskBounds, selectedTaskBounds, modalPivot)
+
+            newSelectedTaskView.modalScale = modalScale
+            newSelectedTaskView.modalPivot = modalPivot
+        }
+    }
+
     companion object {
         class RecentsViewFloatProperty(
             private val utilsProperty: KMutableProperty1<RecentsViewUtils, Float>
diff --git a/quickstep/src/com/android/quickstep/views/TaskContainer.kt b/quickstep/src/com/android/quickstep/views/TaskContainer.kt
index ec6d1c4..afe7e92 100644
--- a/quickstep/src/com/android/quickstep/views/TaskContainer.kt
+++ b/quickstep/src/com/android/quickstep/views/TaskContainer.kt
@@ -21,6 +21,7 @@
 import android.util.Log
 import android.view.View
 import android.view.View.OnClickListener
+import com.android.app.tracing.traceSection
 import com.android.launcher3.Flags.enableRefactorTaskThumbnail
 import com.android.launcher3.model.data.TaskViewItemInfo
 import com.android.launcher3.util.SplitConfigurationOptions
@@ -100,26 +101,28 @@
     val itemInfo: TaskViewItemInfo
         get() = TaskViewItemInfo(taskView, this)
 
-    fun bind() {
-        digitalWellBeingToast?.bind(task, taskView, snapshotView, stagePosition)
-        if (!enableRefactorTaskThumbnail()) {
-            thumbnailViewDeprecated.bind(task, overlay, taskView)
+    fun bind() =
+        traceSection("TaskContainer.bind") {
+            digitalWellBeingToast?.bind(task, taskView, snapshotView, stagePosition)
+            if (!enableRefactorTaskThumbnail()) {
+                thumbnailViewDeprecated.bind(task, overlay, taskView)
+            }
         }
-    }
 
-    fun destroy() {
-        digitalWellBeingToast?.destroy()
-        taskContentView.scaleX = 1f
-        taskContentView.scaleY = 1f
-        overlay.reset()
-        if (enableRefactorTaskThumbnail()) {
-            isThumbnailValid = false
-            thumbnailData = null
-            thumbnailView.onRecycle()
-        } else {
-            thumbnailViewDeprecated.setShowSplashForSplitSelection(false)
+    fun destroy() =
+        traceSection("TaskContainer.destroy") {
+            digitalWellBeingToast?.destroy()
+            taskContentView.scaleX = 1f
+            taskContentView.scaleY = 1f
+            overlay.reset()
+            if (enableRefactorTaskThumbnail()) {
+                isThumbnailValid = false
+                thumbnailData = null
+                thumbnailView.onRecycle()
+            } else {
+                thumbnailViewDeprecated.setShowSplashForSplitSelection(false)
+            }
         }
-    }
 
     fun setOverlayEnabled(enabled: Boolean) {
         if (!enableRefactorTaskThumbnail()) {
@@ -137,23 +140,24 @@
         }
     }
 
-    fun refreshOverlay(thumbnailPosition: ThumbnailPosition?) {
-        this.thumbnailPosition = thumbnailPosition
-        when {
-            !overlayEnabledStatus -> overlay.reset()
-            thumbnailPosition == null -> {
-                Log.e(TAG, "Thumbnail position was null during overlay refresh", Exception())
-                overlay.reset()
+    fun refreshOverlay(thumbnailPosition: ThumbnailPosition?) =
+        traceSection("TaskContainer.refreshOverlay") {
+            this.thumbnailPosition = thumbnailPosition
+            when {
+                !overlayEnabledStatus -> overlay.reset()
+                thumbnailPosition == null -> {
+                    Log.e(TAG, "Thumbnail position was null during overlay refresh", Exception())
+                    overlay.reset()
+                }
+                else ->
+                    overlay.initOverlay(
+                        task,
+                        thumbnailData?.thumbnail,
+                        thumbnailPosition.matrix,
+                        thumbnailPosition.isRotated,
+                    )
             }
-            else ->
-                overlay.initOverlay(
-                    task,
-                    thumbnailData?.thumbnail,
-                    thumbnailPosition.matrix,
-                    thumbnailPosition.isRotated,
-                )
         }
-    }
 
     fun addChildForAccessibility(outChildren: ArrayList<View>) {
         addAccessibleChildToList(iconView.asView(), outChildren)
@@ -168,15 +172,16 @@
         liveTile: Boolean,
         hasHeader: Boolean,
         clickCloseListener: OnClickListener?,
-    ) {
-        taskContentView.setState(
-            TaskUiStateMapper.toTaskHeaderState(state, hasHeader, clickCloseListener),
-            TaskUiStateMapper.toTaskThumbnailUiState(state, liveTile),
-            state?.taskId,
-        )
-        thumbnailData = if (state is TaskData.Data) state.thumbnailData else null
-        overlay.setThumbnailState(thumbnailData)
-    }
+    ) =
+        traceSection("TaskContainer.setState") {
+            taskContentView.setState(
+                TaskUiStateMapper.toTaskHeaderState(state, hasHeader, clickCloseListener),
+                TaskUiStateMapper.toTaskThumbnailUiState(state, liveTile),
+                state?.taskId,
+            )
+            thumbnailData = if (state is TaskData.Data) state.thumbnailData else null
+            overlay.setThumbnailState(thumbnailData)
+        }
 
     fun updateTintAmount(tintAmount: Float) {
         thumbnailView.updateTintAmount(tintAmount)
diff --git a/quickstep/src/com/android/quickstep/views/TaskHeaderView.kt b/quickstep/src/com/android/quickstep/views/TaskHeaderView.kt
index 0427402..1fda5a3 100644
--- a/quickstep/src/com/android/quickstep/views/TaskHeaderView.kt
+++ b/quickstep/src/com/android/quickstep/views/TaskHeaderView.kt
@@ -18,16 +18,16 @@
 
 import android.content.Context
 import android.util.AttributeSet
-import android.widget.FrameLayout
 import android.widget.ImageButton
 import android.widget.ImageView
 import android.widget.TextView
+import androidx.constraintlayout.widget.ConstraintLayout
 import androidx.core.view.isGone
 import com.android.launcher3.R
 import com.android.quickstep.task.thumbnail.TaskHeaderUiState
 
 class TaskHeaderView @JvmOverloads constructor(context: Context, attrs: AttributeSet? = null) :
-    FrameLayout(context, attrs) {
+    ConstraintLayout(context, attrs) {
 
     private val headerTitleView: TextView by lazy { findViewById(R.id.header_app_title) }
     private val headerIconView: ImageView by lazy { findViewById(R.id.header_app_icon) }
diff --git a/quickstep/src/com/android/quickstep/views/TaskMenuView.kt b/quickstep/src/com/android/quickstep/views/TaskMenuView.kt
index 7c762f4..696f934 100644
--- a/quickstep/src/com/android/quickstep/views/TaskMenuView.kt
+++ b/quickstep/src/com/android/quickstep/views/TaskMenuView.kt
@@ -22,11 +22,11 @@
 import android.content.Context
 import android.graphics.Outline
 import android.graphics.Rect
-import android.graphics.drawable.GradientDrawable
 import android.graphics.drawable.ShapeDrawable
 import android.graphics.drawable.shapes.RectShape
 import android.util.AttributeSet
 import android.view.Gravity
+import android.view.KeyEvent
 import android.view.MotionEvent
 import android.view.View
 import android.view.ViewOutlineProvider
@@ -165,7 +165,18 @@
             recentsViewContainer.layoutInflater.inflate(R.layout.task_view_menu_option, this, false)
                 as LinearLayout
         if (enableOverviewIconMenu()) {
-            (menuOptionView.background as GradientDrawable).cornerRadius = 0f
+            menuOptionView.background =
+                ResourcesCompat.getDrawable(
+                    resources,
+                    R.drawable.app_chip_menu_item_bg,
+                    context.theme,
+                )
+            menuOptionView.foreground =
+                ResourcesCompat.getDrawable(
+                    resources,
+                    R.drawable.app_chip_menu_item_fg,
+                    context.theme,
+                )
         }
         menuOption.setIconAndLabelFor(
             menuOptionView.findViewById(R.id.icon),
@@ -366,13 +377,10 @@
             deviceProfile = recentsViewContainer.deviceProfile,
             taskMenuX = translationX,
             taskMenuY =
-                when {
-                    !enableOverviewIconMenu() -> translationY
-                    // Bottom menu can translate up to show more options. So we use the min
-                    // translation allowed to calculate its max height.
-                    taskView.isOnGridBottomRow() -> minMenuTop
-                    else -> menuTranslationYBeforeOpen
-                },
+                // Bottom menu can translate up to show more options. So we use the min
+                // translation allowed to calculate its max height.
+                if (enableOverviewIconMenu() && taskView.isOnGridBottomRow()) minMenuTop
+                else translationY,
         )
 
     private fun setOnClosingStartCallback(onClosingStartCallback: Runnable?) {
@@ -458,6 +466,24 @@
         animatorBuilder.with(menuTranslationXAnim)
     }
 
+    override fun dispatchKeyEvent(event: KeyEvent): Boolean {
+        if (enableOverviewIconMenu()) {
+            if (event.action != KeyEvent.ACTION_DOWN) return super.dispatchKeyEvent(event)
+
+            val isFirstMenuOptionFocused = optionLayout.indexOfChild(optionLayout.focusedChild) == 0
+            val isLastMenuOptionFocused =
+                optionLayout.indexOfChild(optionLayout.focusedChild) == optionLayout.childCount - 1
+            if (
+                (isLastMenuOptionFocused && event.keyCode == KeyEvent.KEYCODE_DPAD_DOWN)
+                || (isFirstMenuOptionFocused && event.keyCode == KeyEvent.KEYCODE_DPAD_UP)
+            ) {
+                iconView.requestFocus()
+                return true
+            }
+        }
+        return super.dispatchKeyEvent(event)
+    }
+
     companion object {
         private val REVEAL_OPEN_DURATION = if (enableOverviewIconMenu()) 417L else 150L
         private val REVEAL_CLOSE_DURATION = if (enableOverviewIconMenu()) 333L else 100L
diff --git a/quickstep/src/com/android/quickstep/views/TaskView.kt b/quickstep/src/com/android/quickstep/views/TaskView.kt
index 55432b8..3835e48 100644
--- a/quickstep/src/com/android/quickstep/views/TaskView.kt
+++ b/quickstep/src/com/android/quickstep/views/TaskView.kt
@@ -33,6 +33,7 @@
 import android.view.Display
 import android.view.MotionEvent
 import android.view.View
+import android.view.View.OnClickListener
 import android.view.ViewGroup
 import android.view.ViewStub
 import android.view.accessibility.AccessibilityNodeInfo
@@ -42,6 +43,8 @@
 import androidx.annotation.VisibleForTesting
 import androidx.core.view.updateLayoutParams
 import com.android.app.animation.Interpolators
+import com.android.app.tracing.traceSection
+import com.android.launcher3.AbstractFloatingView
 import com.android.launcher3.Flags.enableCursorHoverStates
 import com.android.launcher3.Flags.enableDesktopExplodedView
 import com.android.launcher3.Flags.enableGridOnlyOverview
@@ -75,6 +78,7 @@
 import com.android.quickstep.FullscreenDrawParams
 import com.android.quickstep.RecentsModel
 import com.android.quickstep.RemoteAnimationTargets
+import com.android.quickstep.RemoteTargetGluer.RemoteTargetHandle
 import com.android.quickstep.TaskOverlayFactory
 import com.android.quickstep.TaskViewUtils
 import com.android.quickstep.orientation.RecentsPagedOrientationHandler
@@ -141,11 +145,13 @@
         /** Returns whether the task is part of overview grid and not being focused. */
         get() = container.deviceProfile.isTablet && !isLargeTile
 
-    // TODO: b/400532675 - This will not work for empty desks until b/400532675 is fixed.
     val isRunningTask: Boolean
         get() = this === recentsView?.runningTaskView
 
-    val displayId: Int
+    private val isSelectedTask: Boolean
+        get() = this === recentsView?.selectedTaskView
+
+    open val displayId: Int
         get() = taskContainers.firstOrNull()?.task.displayId
 
     val isExternalDisplay: Boolean
@@ -335,6 +341,12 @@
             onModalnessUpdated(field)
         }
 
+    var modalPivot: PointF? = null
+        set(value) {
+            field = value
+            updatePivots()
+        }
+
     var splitSplashAlpha = 0f
         set(value) {
             field = value
@@ -359,6 +371,12 @@
             applyScale()
         }
 
+    var modalScale = 1f
+        set(value) {
+            field = value
+            applyScale()
+        }
+
     private var dismissTranslationX = 0f
         set(value) {
             field = value
@@ -444,9 +462,10 @@
         }
 
     private val taskViewAlpha = MultiValueAlpha(this, Alpha.entries.size)
-    protected var stableAlpha by MultiPropertyDelegate(taskViewAlpha, Alpha.STABLE)
-    var attachAlpha by MultiPropertyDelegate(taskViewAlpha, Alpha.ATTACH)
-    var splitAlpha by MultiPropertyDelegate(taskViewAlpha, Alpha.SPLIT)
+    protected var stableAlpha by MultiPropertyDelegate(taskViewAlpha, Alpha.Stable)
+    var attachAlpha by MultiPropertyDelegate(taskViewAlpha, Alpha.Attach)
+    var splitAlpha by MultiPropertyDelegate(taskViewAlpha, Alpha.Split)
+    private var modalAlpha by MultiPropertyDelegate(taskViewAlpha, Alpha.Modal)
 
     protected var shouldShowScreenshot = false
         get() = !isRunningTask || field
@@ -614,16 +633,19 @@
         super.draw(canvas)
     }
 
+    override fun setLayoutDirection(layoutDirection: Int) {
+        super.setLayoutDirection(layoutDirection)
+        if (enableOverviewIconMenu()) {
+            val deviceLayoutDirection = resources.configuration.layoutDirection
+            taskContainers.forEach {
+                (it.iconView as IconAppChipView).layoutDirection = deviceLayoutDirection
+            }
+        }
+    }
+
     override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
         super.onLayout(changed, left, top, right, bottom)
-        val thumbnailTopMargin = container.deviceProfile.overviewTaskThumbnailTopMarginPx
-        if (container.deviceProfile.isTablet) {
-            pivotX = (if (layoutDirection == LAYOUT_DIRECTION_RTL) 0 else right - left).toFloat()
-            pivotY = thumbnailTopMargin.toFloat()
-        } else {
-            pivotX = (right - left) * 0.5f
-            pivotY = thumbnailTopMargin + (height - thumbnailTopMargin) * 0.5f
-        }
+        updatePivots()
         systemGestureExclusionRects =
             SYSTEM_GESTURE_EXCLUSION_RECT.onEach {
                 it.right = width
@@ -634,6 +656,24 @@
         }
     }
 
+    private fun updatePivots() {
+        val modalPivot = modalPivot
+        if (modalPivot != null) {
+            pivotX = modalPivot.x
+            pivotY = modalPivot.y
+        } else {
+            val thumbnailTopMargin = container.deviceProfile.overviewTaskThumbnailTopMarginPx
+            if (container.deviceProfile.isTablet) {
+                pivotX =
+                    (if (layoutDirection == LAYOUT_DIRECTION_RTL) 0 else right - left).toFloat()
+                pivotY = thumbnailTopMargin.toFloat()
+            } else {
+                pivotX = (right - left) * 0.5f
+                pivotY = thumbnailTopMargin + (height - thumbnailTopMargin) * 0.5f
+            }
+        }
+    }
+
     override fun onRecycle() {
         resetPersistentViewTransforms()
 
@@ -641,6 +681,9 @@
         attachAlpha = 1f
         splitAlpha = 1f
         splitSplashAlpha = 0f
+        modalAlpha = 1f
+        modalScale = 1f
+        modalPivot = null
         taskThumbnailSplashAlpha = 0f
         // Clear any references to the thumbnail (it will be re-read either from the cache or the
         // system on next bind)
@@ -734,61 +777,63 @@
             ?.inflate()
     }
 
-    override fun onAttachedToWindow() {
-        super.onAttachedToWindow()
-        if (enableRefactorTaskThumbnail()) {
-            // The TaskView lifecycle is starts the ViewModel during onBind, and cleans it in
-            // onRecycle. So it should be initialized at this point. TaskView Lifecycle:
-            // `bind` -> `onBind` ->  onAttachedToWindow() -> onDetachFromWindow -> onRecycle
-            coroutineJobs +=
-                coroutineScope.launch(dispatcherProvider.main) {
-                    viewModel!!.state.collectLatest(::updateTaskViewState)
-                }
-        }
-    }
-
-    private fun updateTaskViewState(state: TaskTileUiState) {
-        sysUiStatusNavFlags = state.sysUiStatusNavFlags
-
-        // Updating containers
-        val mapOfTasks = state.tasks.associateBy { it.taskId }
-        taskContainers.forEach { container ->
-            val taskId = container.task.key.id
-            val containerState = mapOfTasks[taskId]
-            val shouldHaveHeader = (type == TaskViewType.DESKTOP) && enableDesktopExplodedView()
-            container.setState(
-                state = containerState,
-                liveTile = state.isLiveTile,
-                hasHeader = shouldHaveHeader,
-                clickCloseListener =
-                    if (shouldHaveHeader) {
-                        {
-                            // Update the layout UI to remove this task from the layout grid, and
-                            // remove the task from ActivityManager afterwards.
-                            recentsView?.dismissTask(
-                                taskId,
-                                /* animate= */ true,
-                                /* removeTask= */ true,
-                            )
-                        }
-                    } else {
-                        null
-                    },
-            )
-            updateThumbnailValidity(container)
-            val thumbnailPosition =
-                updateThumbnailMatrix(
-                    container = container,
-                    width = container.thumbnailView.width,
-                    height = container.thumbnailView.height,
-                )
-            container.setOverlayEnabled(state.taskOverlayEnabled, thumbnailPosition)
-
-            if (enableOverviewIconMenu()) {
-                setIconState(container, containerState)
+    override fun onAttachedToWindow() =
+        traceSection("TaskView.onAttachedToWindow") {
+            super.onAttachedToWindow()
+            if (enableRefactorTaskThumbnail()) {
+                // The TaskView lifecycle is starts the ViewModel during onBind, and cleans it in
+                // onRecycle. So it should be initialized at this point. TaskView Lifecycle:
+                // `bind` -> `onBind` ->  onAttachedToWindow() -> onDetachFromWindow -> onRecycle
+                coroutineJobs +=
+                    coroutineScope.launch(dispatcherProvider.main) {
+                        viewModel!!.state.collectLatest(::updateTaskViewState)
+                    }
             }
         }
-    }
+
+    private fun updateTaskViewState(state: TaskTileUiState) =
+        traceSection("TaskView.updateTaskViewState") {
+            sysUiStatusNavFlags = state.sysUiStatusNavFlags
+
+            // Updating containers
+            val mapOfTasks = state.tasks.associateBy { it.taskId }
+            taskContainers.forEach { container ->
+                val taskId = container.task.key.id
+                val containerState = mapOfTasks[taskId]
+                val shouldHaveHeader = (type == TaskViewType.DESKTOP) && enableDesktopExplodedView()
+                container.setState(
+                    state = containerState,
+                    liveTile = state.isLiveTile,
+                    hasHeader = shouldHaveHeader,
+                    clickCloseListener =
+                        if (shouldHaveHeader) {
+                            {
+                                // Update the layout UI to remove this task from the layout grid,
+                                // and remove the task from ActivityManager afterwards.
+                                recentsView?.dismissTask(
+                                    taskId,
+                                    /* animate= */ true,
+                                    /* removeTask= */ true,
+                                )
+                            }
+                        } else {
+                            null
+                        },
+                )
+                updateThumbnailValidity(container)
+                val thumbnailPosition =
+                    updateThumbnailMatrix(
+                        container = container,
+                        width = container.thumbnailView.width,
+                        height = container.thumbnailView.height,
+                    )
+                container.setOverlayEnabled(state.taskOverlayEnabled, thumbnailPosition)
+
+                if (enableOverviewIconMenu()) {
+                    setIconState(container, containerState)
+                }
+            }
+        }
 
     private fun updateThumbnailValidity(container: TaskContainer) {
         container.isThumbnailValid =
@@ -815,27 +860,33 @@
         container: TaskContainer,
         width: Int,
         height: Int,
-    ): ThumbnailPosition? {
-        val thumbnailPosition =
-            viewModel?.getThumbnailPosition(container.thumbnailData, width, height, isLayoutRtl)
-                ?: return null
-        container.updateThumbnailMatrix(thumbnailPosition.matrix)
-        return thumbnailPosition
-    }
+    ): ThumbnailPosition? =
+        traceSection("TaskView.updateThumbnailMatrix") {
+            val thumbnailPosition =
+                viewModel?.getThumbnailPosition(container.thumbnailData, width, height, isLayoutRtl)
+                    ?: return null
+            container.updateThumbnailMatrix(thumbnailPosition.matrix)
+            return thumbnailPosition
+        }
 
-    override fun onDetachedFromWindow() {
-        super.onDetachedFromWindow()
-        if (enableRefactorTaskThumbnail()) {
-            // The jobs are being cancelled in the background thread. So we make a copy of the list
-            // to prevent cleaning a new job that might be added to this list during onAttach
-            // or another moment in the lifecycle.
-            val coroutineJobsToCancel = coroutineJobs.toList()
-            coroutineJobs.clear()
-            coroutineScope.launch(dispatcherProvider.background) {
-                coroutineJobsToCancel.forEach { it.cancel("TaskView detaching from window") }
+    override fun onDetachedFromWindow() =
+        traceSection("TaskView.onDetachedFromWindow") {
+            super.onDetachedFromWindow()
+            if (enableRefactorTaskThumbnail()) {
+                // The jobs are being cancelled in the background thread. So we make a copy of the
+                // list to prevent cleaning a new job that might be added to this list during
+                // onAttach or another moment in the lifecycle.
+                val coroutineJobsToCancel = coroutineJobs.toList()
+                coroutineJobs.clear()
+                coroutineScope.launch(dispatcherProvider.background) {
+                    traceSection("TaskView.onDetachedFromWindow.cancellingJobs") {
+                        coroutineJobsToCancel.forEach {
+                            it.cancel("TaskView detaching from window")
+                        }
+                    }
+                }
             }
         }
-    }
 
     /** Updates this task view to the given {@param task}. */
     open fun bind(
@@ -861,37 +912,40 @@
         onBind(orientedState)
     }
 
-    protected open fun onBind(orientedState: RecentsOrientedState) {
-        if (enableRefactorTaskThumbnail()) {
-            val scopeId = context
-            Log.d(TAG, "onBind $scopeId ${orientedState.containerInterface}")
-            viewModel =
-                TaskViewModel(
-                        taskViewType = type,
-                        recentsViewData = RecentsDependencies.get(scopeId),
-                        getTaskUseCase = RecentsDependencies.get(scopeId),
-                        getSysUiStatusNavFlagsUseCase = RecentsDependencies.get(scopeId),
-                        isThumbnailValidUseCase = RecentsDependencies.get(scopeId),
-                        getThumbnailPositionUseCase = RecentsDependencies.get(scopeId),
-                        dispatcherProvider = RecentsDependencies.get(scopeId),
-                    )
-                    .apply { bind(*taskIds) }
-        }
-
-        taskContainers.forEach { container ->
-            container.bind()
-            if (enableRefactorTaskThumbnail()) {
-                container.taskContentView.cornerRadius =
-                    thumbnailFullscreenParams.currentCornerRadius
-                container.taskContentView.doOnSizeChange { width, height ->
-                    updateThumbnailValidity(container)
-                    val thumbnailPosition = updateThumbnailMatrix(container, width, height)
-                    container.refreshOverlay(thumbnailPosition)
+    protected open fun onBind(orientedState: RecentsOrientedState) =
+        traceSection("TaskView.onBind") {
+            traceSection("TaskView.onBind.createViewModel") {
+                if (enableRefactorTaskThumbnail()) {
+                    val scopeId = context
+                    Log.d(TAG, "onBind $scopeId ${orientedState.containerInterface}")
+                    viewModel =
+                        TaskViewModel(
+                                taskViewType = type,
+                                recentsViewData = RecentsDependencies.get(scopeId),
+                                getTaskUseCase = RecentsDependencies.get(scopeId),
+                                getSysUiStatusNavFlagsUseCase = RecentsDependencies.get(scopeId),
+                                isThumbnailValidUseCase = RecentsDependencies.get(scopeId),
+                                getThumbnailPositionUseCase = RecentsDependencies.get(scopeId),
+                                dispatcherProvider = RecentsDependencies.get(scopeId),
+                            )
+                            .apply { bind(*taskIds) }
                 }
             }
+
+            taskContainers.forEach { container ->
+                container.bind()
+                if (enableRefactorTaskThumbnail()) {
+                    container.taskContentView.cornerRadius =
+                        thumbnailFullscreenParams.currentCornerRadius
+                    container.taskContentView.doOnSizeChange { width, height ->
+                        updateThumbnailValidity(container)
+                        val thumbnailPosition = updateThumbnailMatrix(container, width, height)
+                        container.refreshOverlay(thumbnailPosition)
+                    }
+                }
+            }
+            setOrientationState(orientedState)
         }
-        setOrientationState(orientedState)
-    }
 
     private fun applyThumbnailSplashAlpha() {
         val alpha = getSplashAlphaProgress()
@@ -917,22 +971,23 @@
         @IdRes digitalWellbeingBannerId: Int,
         @StagePosition stagePosition: Int,
         taskOverlayFactory: TaskOverlayFactory,
-    ): TaskContainer {
-        val iconView = findViewById<View>(iconViewId) as TaskViewIcon
-        val taskContentView = findViewById<TaskContentView>(taskContentViewId)
-        return TaskContainer(
-            this,
-            task,
-            taskContentView,
-            taskContentView.findViewById(thumbnailViewId),
-            iconView,
-            TransformingTouchDelegate(iconView.asView()),
-            stagePosition,
-            findViewById(digitalWellbeingBannerId)!!,
-            findViewById(showWindowViewId)!!,
-            taskOverlayFactory,
-        )
-    }
+    ): TaskContainer =
+        traceSection("TaskView.createTaskContainer") {
+            val iconView = findViewById<View>(iconViewId) as TaskViewIcon
+            val taskContentView = findViewById<TaskContentView>(taskContentViewId)
+            return TaskContainer(
+                this,
+                task,
+                taskContentView,
+                taskContentView.findViewById(thumbnailViewId),
+                iconView,
+                TransformingTouchDelegate(iconView.asView()),
+                stagePosition,
+                findViewById(digitalWellbeingBannerId)!!,
+                findViewById(showWindowViewId)!!,
+                taskOverlayFactory,
+            )
+        }
 
     fun containsMultipleTasks() = taskContainers.size > 1
 
@@ -945,11 +1000,12 @@
     /** Check if given `taskId` is tracked in this view */
     fun containsTaskId(taskId: Int) = getTaskContainerById(taskId) != null
 
-    open fun setOrientationState(orientationState: RecentsOrientedState) {
-        this.orientedState = orientationState
-        taskContainers.forEach { it.iconView.setIconOrientation(orientationState, isGridTask) }
-        setThumbnailOrientation(orientationState)
-    }
+    open fun setOrientationState(orientationState: RecentsOrientedState) =
+        traceSection("TaskView.setOrientationState") {
+            this.orientedState = orientationState
+            taskContainers.forEach { it.iconView.setIconOrientation(orientationState, isGridTask) }
+            setThumbnailOrientation(orientationState)
+        }
 
     protected open fun setThumbnailOrientation(orientationState: RecentsOrientedState) {
         taskContainers.forEach {
@@ -1096,25 +1152,27 @@
     protected open fun needsUpdate(@TaskDataChanges dataChange: Int, @TaskDataChanges flag: Int) =
         (dataChange and flag) == flag
 
-    protected open fun cancelPendingLoadTasks() {
-        pendingThumbnailLoadRequests.forEach { it.cancel() }
-        pendingThumbnailLoadRequests.clear()
-        pendingIconLoadRequests.forEach { it.cancel() }
-        pendingIconLoadRequests.clear()
-    }
+    protected open fun cancelPendingLoadTasks() =
+        traceSection("TaskView.cancelPendingLoadTasks") {
+            pendingThumbnailLoadRequests.forEach { it.cancel() }
+            pendingThumbnailLoadRequests.clear()
+            pendingIconLoadRequests.forEach { it.cancel() }
+            pendingIconLoadRequests.clear()
+        }
 
-    protected open fun setIconState(container: TaskContainer, state: TaskData?) {
-        if (enableOverviewIconMenu()) {
-            if (state is TaskData.Data) {
-                setIcon(container.iconView, state.icon)
-                container.iconView.setText(state.title)
-                container.digitalWellBeingToast?.initialize()
-            } else {
-                setIcon(container.iconView, null)
-                container.iconView.setText(null)
+    protected open fun setIconState(container: TaskContainer, state: TaskData?) =
+        traceSection("TaskView.setIconState") {
+            if (enableOverviewIconMenu()) {
+                if (state is TaskData.Data) {
+                    setIcon(container.iconView, state.icon)
+                    container.iconView.setText(state.title)
+                    container.digitalWellBeingToast?.initialize()
+                } else {
+                    setIcon(container.iconView, null)
+                    container.iconView.setText(null)
+                }
             }
         }
-    }
 
     protected open fun onIconLoaded(taskContainer: TaskContainer) {
         setIcon(taskContainer.iconView, taskContainer.task.icon)
@@ -1194,15 +1252,14 @@
     /** Launch of the current task (both live and inactive tasks) with an animation. */
     fun launchWithAnimation(): RunnableList? {
         return if (isRunningTask && recentsView?.remoteTargetHandles != null) {
-            launchAsLiveTile()
+            launchAsLiveTile(recentsView?.remoteTargetHandles!!)
         } else {
             launchAsStaticTile()
         }
     }
 
-    private fun launchAsLiveTile(): RunnableList? {
+    private fun launchAsLiveTile(remoteTargetHandles: Array<RemoteTargetHandle>): RunnableList? {
         val recentsView = recentsView ?: return null
-        val remoteTargetHandles = recentsView.remoteTargetHandles
         if (!isClickableAsLiveTile) {
             Log.e(
                 TAG,
@@ -1212,21 +1269,27 @@
         }
         isClickableAsLiveTile = false
         val targets =
-            if (remoteTargetHandles.size == 1) {
-                remoteTargetHandles[0].transformParams.targetSet
+            if (remoteTargetHandles.isNotEmpty()) {
+                if (remoteTargetHandles.size == 1) {
+                    remoteTargetHandles[0].transformParams.targetSet
+                } else {
+                    val apps =
+                        remoteTargetHandles.flatMap {
+                            it.transformParams.targetSet.apps.asIterable()
+                        }
+                    val wallpapers =
+                        remoteTargetHandles.flatMap {
+                            it.transformParams.targetSet.wallpapers.asIterable()
+                        }
+                    RemoteAnimationTargets(
+                        apps.toTypedArray(),
+                        wallpapers.toTypedArray(),
+                        remoteTargetHandles[0].transformParams.targetSet.nonApps,
+                        remoteTargetHandles[0].transformParams.targetSet.targetMode,
+                    )
+                }
             } else {
-                val apps =
-                    remoteTargetHandles.flatMap { it.transformParams.targetSet.apps.asIterable() }
-                val wallpapers =
-                    remoteTargetHandles.flatMap {
-                        it.transformParams.targetSet.wallpapers.asIterable()
-                    }
-                RemoteAnimationTargets(
-                    apps.toTypedArray(),
-                    wallpapers.toTypedArray(),
-                    remoteTargetHandles[0].transformParams.targetSet.nonApps,
-                    remoteTargetHandles[0].transformParams.targetSet.targetMode,
-                )
+                null
             }
         if (targets == null) {
             // If the recents animation is cancelled somehow between the parent if block and
@@ -1254,7 +1317,7 @@
                 targets.apps,
                 targets.wallpapers,
                 targets.nonApps,
-                true /* launcherClosing */,
+                true, /* launcherClosing */
                 recentsView.stateManager,
                 recentsView,
                 recentsView.depthController,
@@ -1467,6 +1530,20 @@
         return showTaskMenuWithContainer(menuContainer)
     }
 
+    private fun closeTaskMenu(): Boolean {
+        val floatingView: AbstractFloatingView? =
+            AbstractFloatingView.getTopOpenViewWithType(
+                container,
+                AbstractFloatingView.TYPE_TASK_MENU,
+            )
+        if (floatingView?.isOpen == true) {
+            floatingView.close(true)
+            return true
+        } else {
+            return false
+        }
+    }
+
     private fun showTaskMenuWithContainer(menuContainer: TaskContainer): Boolean {
         val recentsView = recentsView ?: return false
         if (enableHoverOfChildElementsInTaskview()) {
@@ -1474,12 +1551,16 @@
             recentsView.setTaskBorderEnabled(false)
         }
         return if (enableOverviewIconMenu() && menuContainer.iconView is IconAppChipView) {
-            menuContainer.iconView.revealAnim(/* isRevealing= */ true)
-            TaskMenuView.showForTask(menuContainer) {
-                val isAnimated = !recentsView.isSplitSelectionActive
-                menuContainer.iconView.revealAnim(/* isRevealing= */ false, isAnimated)
-                if (enableHoverOfChildElementsInTaskview()) {
-                    recentsView.setTaskBorderEnabled(true)
+            if (menuContainer.iconView.isExpanded) {
+                closeTaskMenu()
+            } else {
+                menuContainer.iconView.revealAnim(/* isRevealing= */ true)
+                TaskMenuView.showForTask(menuContainer) {
+                    val isAnimated = !recentsView.isSplitSelectionActive
+                    menuContainer.iconView.revealAnim(/* isRevealing= */ false, isAnimated)
+                    if (enableHoverOfChildElementsInTaskview()) {
+                        recentsView.setTaskBorderEnabled(true)
+                    }
                 }
             }
         } else if (container.deviceProfile.isTablet) {
@@ -1672,7 +1753,7 @@
     fun getSizeAdjustment(fullscreenEnabled: Boolean) = if (fullscreenEnabled) nonGridScale else 1f
 
     private fun applyScale() {
-        val scale = persistentScale * dismissScale
+        val scale = persistentScale * dismissScale * Utilities.mapRange(modalness, 1f, modalScale)
         scaleX = scale
         scaleY = scale
         updateFullscreenParams()
@@ -1734,9 +1815,13 @@
     private fun onModalnessUpdated(modalness: Float) {
         isClickable = modalness == 0f
         taskContainers.forEach {
-            it.iconView.setModalAlpha(1 - modalness)
+            it.iconView.setModalAlpha(1f - modalness)
             it.digitalWellBeingToast?.bannerOffsetPercentage = modalness
         }
+        if (enableGridOnlyOverview()) {
+            modalAlpha = if (isSelectedTask) 1f else (1f - modalness)
+            applyScale()
+        }
     }
 
     fun resetPersistentViewTransforms() {
@@ -1792,9 +1877,10 @@
         private const val TAG = "TaskView"
 
         private enum class Alpha {
-            STABLE,
-            ATTACH,
-            SPLIT,
+            Stable,
+            Attach,
+            Split,
+            Modal,
         }
 
         private enum class SettledProgress {
diff --git a/quickstep/src_protolog/com/android/quickstep/util/ActiveGestureProtoLogProxy.java b/quickstep/src_protolog/com/android/quickstep/util/ActiveGestureProtoLogProxy.java
index 18a5338..773a039 100644
--- a/quickstep/src_protolog/com/android/quickstep/util/ActiveGestureProtoLogProxy.java
+++ b/quickstep/src_protolog/com/android/quickstep/util/ActiveGestureProtoLogProxy.java
@@ -551,4 +551,13 @@
                 displayRotation, displaySize.flattenToString(), swipeRegion.toShortString(),
                 ohmRegion.toShortString(), gesturalHeight, largerGesturalHeight, reason);
     }
+
+    public static void logOnTaskAnimationManagerNotAvailable(int displayId) {
+        ActiveGestureLog.INSTANCE.addLog(new ActiveGestureLog.CompoundString(
+                "TaskAnimationManager not available for displayId=%d",
+                displayId));
+        if (!enableActiveGestureProtoLog() || !isProtoLogInitialized()) return;
+        ProtoLog.d(ACTIVE_GESTURE_LOG, "TaskAnimationManager not available for displayId=%d",
+                displayId);
+    }
 }
diff --git a/quickstep/tests/multivalentScreenshotTests/src/com/android/quickstep/task/thumbnail/TaskContentViewScreenshotTest.kt b/quickstep/tests/multivalentScreenshotTests/src/com/android/quickstep/task/thumbnail/TaskContentViewScreenshotTest.kt
index d36faa2..7b1e445 100644
--- a/quickstep/tests/multivalentScreenshotTests/src/com/android/quickstep/task/thumbnail/TaskContentViewScreenshotTest.kt
+++ b/quickstep/tests/multivalentScreenshotTests/src/com/android/quickstep/task/thumbnail/TaskContentViewScreenshotTest.kt
@@ -18,11 +18,15 @@
 import android.content.Context
 import android.graphics.Color
 import android.graphics.drawable.BitmapDrawable
+import android.platform.test.flag.junit.SetFlagsRule
 import android.view.LayoutInflater
+import com.android.launcher3.Flags
 import com.android.launcher3.R
+import com.android.launcher3.util.rule.setFlags
 import com.android.quickstep.task.thumbnail.SplashHelper.createSplash
 import com.android.quickstep.task.thumbnail.TaskThumbnailUiState.BackgroundOnly
 import com.google.android.apps.nexuslauncher.imagecomparison.goldenpathmanager.ViewScreenshotGoldenPathManager
+import org.junit.Before
 import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -37,13 +41,20 @@
 @RunWith(ParameterizedAndroidJunit4::class)
 class TaskContentViewScreenshotTest(emulationSpec: DeviceEmulationSpec) {
 
-    @get:Rule
+    @get:Rule(order = 0) val setFlagsRule = SetFlagsRule()
+
+    @get:Rule(order = 1)
     val screenshotRule =
         ViewScreenshotTestRule(
             emulationSpec,
             ViewScreenshotGoldenPathManager(getEmulatedDevicePathConfig(emulationSpec)),
         )
 
+    @Before
+    fun setUp() {
+        setFlagsRule.setFlags(true, Flags.FLAG_ENABLE_REFACTOR_TASK_THUMBNAIL)
+    }
+
     @Test
     fun taskContentView_recyclesToUninitialized() {
         screenshotRule.screenshotTest("taskContentView_uninitialized") { activity ->
diff --git a/quickstep/tests/multivalentTests/src/com/android/launcher3/model/QuickstepModelDelegateTest.kt b/quickstep/tests/multivalentTests/src/com/android/launcher3/model/QuickstepModelDelegateTest.kt
index 09c62aa..1c7af14 100644
--- a/quickstep/tests/multivalentTests/src/com/android/launcher3/model/QuickstepModelDelegateTest.kt
+++ b/quickstep/tests/multivalentTests/src/com/android/launcher3/model/QuickstepModelDelegateTest.kt
@@ -64,7 +64,7 @@
         underTest.mHotseatState.predictor = hotseatPredictor
         underTest.mWidgetsRecommendationState.predictor = widgetRecommendationPredictor
         underTest.mModel = modelHelper.model
-        underTest.mDataModel = BgDataModel()
+        underTest.mDataModel = BgDataModel(WidgetsModel(modelHelper.sandboxContext))
     }
 
     @After
diff --git a/quickstep/tests/multivalentTests/src/com/android/launcher3/taskbar/TaskbarBaseTestCase.kt b/quickstep/tests/multivalentTests/src/com/android/launcher3/taskbar/TaskbarBaseTestCase.kt
index 26f1197..52d288a 100644
--- a/quickstep/tests/multivalentTests/src/com/android/launcher3/taskbar/TaskbarBaseTestCase.kt
+++ b/quickstep/tests/multivalentTests/src/com/android/launcher3/taskbar/TaskbarBaseTestCase.kt
@@ -17,6 +17,7 @@
 
 import com.android.launcher3.taskbar.allapps.TaskbarAllAppsController
 import com.android.launcher3.taskbar.bubbles.BubbleControllers
+import com.android.launcher3.taskbar.growth.NudgeController
 import com.android.launcher3.taskbar.overlay.TaskbarOverlayController
 import com.android.systemui.shared.rotation.RotationButtonController
 import java.util.Optional
@@ -58,6 +59,7 @@
     @Mock lateinit var taskbarPinningController: TaskbarPinningController
     @Mock lateinit var optionalBubbleControllers: Optional<BubbleControllers>
     @Mock lateinit var taskbarDesktopModeController: TaskbarDesktopModeController
+    @Mock lateinit var nudgeController: NudgeController
 
     lateinit var taskbarControllers: TaskbarControllers
 
@@ -100,6 +102,7 @@
                 taskbarPinningController,
                 optionalBubbleControllers,
                 taskbarDesktopModeController,
+                nudgeController,
             )
     }
 }
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 3761044..c589415 100644
--- a/quickstep/tests/multivalentTests/src/com/android/launcher3/taskbar/TaskbarOverflowTest.kt
+++ b/quickstep/tests/multivalentTests/src/com/android/launcher3/taskbar/TaskbarOverflowTest.kt
@@ -23,6 +23,7 @@
 import android.platform.test.annotations.DisableFlags
 import android.platform.test.annotations.EnableFlags
 import android.platform.test.flag.junit.SetFlagsRule
+import android.view.Display.DEFAULT_DISPLAY
 import androidx.test.core.app.ApplicationProvider
 import com.android.launcher3.Flags.FLAG_ENABLE_MULTI_INSTANCE_MENU_TASKBAR
 import com.android.launcher3.Flags.FLAG_TASKBAR_OVERFLOW
@@ -446,7 +447,7 @@
                 )
             })
 
-        recentsModel.updateRecentTasks(listOf(DesktopTask(deskId = 0, tasks)))
+        recentsModel.updateRecentTasks(listOf(DesktopTask(deskId = 0, DEFAULT_DISPLAY, tasks)))
         for (task in 1..tasks.size) {
             desktopTaskListener?.onTasksVisibilityChanged(
                 context.virtualDisplay.display.displayId,
diff --git a/quickstep/tests/multivalentTests/src/com/android/launcher3/taskbar/TaskbarRecentAppsControllerTest.kt b/quickstep/tests/multivalentTests/src/com/android/launcher3/taskbar/TaskbarRecentAppsControllerTest.kt
index 8376bc1..334d8ab 100644
--- a/quickstep/tests/multivalentTests/src/com/android/launcher3/taskbar/TaskbarRecentAppsControllerTest.kt
+++ b/quickstep/tests/multivalentTests/src/com/android/launcher3/taskbar/TaskbarRecentAppsControllerTest.kt
@@ -25,6 +25,7 @@
 import android.os.Process
 import android.os.UserHandle
 import android.platform.test.annotations.EnableFlags
+import android.view.Display.DEFAULT_DISPLAY
 import androidx.test.annotation.UiThreadTest
 import com.android.internal.R
 import com.android.launcher3.BubbleTextView.RunningAppState
@@ -877,7 +878,7 @@
         val allTasks =
             ArrayList<GroupTask>().apply {
                 if (!runningTasks.isEmpty()) {
-                    add(DesktopTask(deskId = 0, ArrayList(runningTasks)))
+                    add(DesktopTask(deskId = 0, DEFAULT_DISPLAY, ArrayList(runningTasks)))
                 }
                 addAll(recentTasks)
             }
@@ -959,7 +960,7 @@
     private fun setInDesktopMode(inDesktopMode: Boolean) {
         whenever(taskbarControllers.taskbarDesktopModeController.shouldShowDesktopTasksInTaskbar())
             .thenReturn(inDesktopMode)
-        whenever(taskbarControllers.taskbarDesktopModeController.isInDesktopMode)
+        whenever(taskbarControllers.taskbarDesktopModeController.isInDesktopMode(DEFAULT_DISPLAY))
             .thenReturn(inDesktopMode)
     }
 
diff --git a/quickstep/tests/multivalentTests/src/com/android/quickstep/AbsSwipeUpHandlerTestCase.java b/quickstep/tests/multivalentTests/src/com/android/quickstep/AbsSwipeUpHandlerTestCase.java
index 6fbbd59..7824000 100644
--- a/quickstep/tests/multivalentTests/src/com/android/quickstep/AbsSwipeUpHandlerTestCase.java
+++ b/quickstep/tests/multivalentTests/src/com/android/quickstep/AbsSwipeUpHandlerTestCase.java
@@ -49,6 +49,7 @@
 import android.platform.test.annotations.DisableFlags;
 import android.platform.test.annotations.EnableFlags;
 import android.platform.test.flag.junit.SetFlagsRule;
+import android.view.Display;
 import android.view.RemoteAnimationTarget;
 import android.view.SurfaceControl;
 import android.view.ViewTreeObserver;
@@ -189,7 +190,7 @@
     @Before
     public void setUpRecentsContainer() {
         mTaskAnimationManager = new TaskAnimationManager(mContext,
-                RecentsAnimationDeviceState.INSTANCE.get(mContext));
+                RecentsAnimationDeviceState.INSTANCE.get(mContext), Display.DEFAULT_DISPLAY);
         RecentsViewContainer recentsContainer = getRecentsContainer();
         RECENTS_VIEW recentsView = getRecentsView();
 
diff --git a/quickstep/tests/multivalentTests/src/com/android/quickstep/OverviewCommandHelperTest.kt b/quickstep/tests/multivalentTests/src/com/android/quickstep/OverviewCommandHelperTest.kt
index 56c01f9..11e0ee8 100644
--- a/quickstep/tests/multivalentTests/src/com/android/quickstep/OverviewCommandHelperTest.kt
+++ b/quickstep/tests/multivalentTests/src/com/android/quickstep/OverviewCommandHelperTest.kt
@@ -17,6 +17,7 @@
 package com.android.quickstep
 
 import android.platform.test.flag.junit.SetFlagsRule
+import android.view.Display.DEFAULT_DISPLAY
 import androidx.test.filters.SmallTest
 import com.android.launcher3.Flags
 import com.android.launcher3.util.LauncherMultivalentJUnit
@@ -25,6 +26,7 @@
 import com.android.quickstep.OverviewCommandHelper.CommandInfo
 import com.android.quickstep.OverviewCommandHelper.CommandInfo.CommandStatus
 import com.android.quickstep.OverviewCommandHelper.CommandType
+import com.android.quickstep.fallback.window.RecentsDisplayModel
 import com.google.common.truth.Truth.assertThat
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.delay
@@ -41,9 +43,9 @@
 import org.junit.runner.RunWith
 import org.mockito.Mockito.doAnswer
 import org.mockito.Mockito.spy
-import org.mockito.Mockito.`when`
 import org.mockito.kotlin.any
 import org.mockito.kotlin.mock
+import org.mockito.kotlin.whenever
 
 @SmallTest
 @RunWith(LauncherMultivalentJUnit::class)
@@ -57,19 +59,38 @@
 
     private var pendingCallbacksWithDelays = mutableListOf<Long>()
 
+    private val recentsDisplayModel: RecentsDisplayModel = mock()
+    private val defaultDisplayResource: RecentsDisplayModel.RecentsDisplayResource = mock()
+    private val secondaryDisplayResource: RecentsDisplayModel.RecentsDisplayResource = mock()
+    private val executeCommandDisplayIds = mutableListOf<Int>()
+
+    private fun setupDefaultDisplay() {
+        whenever(defaultDisplayResource.displayId).thenReturn(DEFAULT_DISPLAY)
+        whenever(recentsDisplayModel.activeDisplayResources)
+            .thenReturn(listOf(defaultDisplayResource))
+    }
+
+    private fun setupMultipleDisplays() {
+        whenever(defaultDisplayResource.displayId).thenReturn(DEFAULT_DISPLAY)
+        whenever(secondaryDisplayResource.displayId).thenReturn(1)
+        whenever(recentsDisplayModel.activeDisplayResources)
+            .thenReturn(listOf(defaultDisplayResource, secondaryDisplayResource))
+    }
+
     @Suppress("UNCHECKED_CAST")
     @Before
     fun setup() {
         setFlagsRule.setFlags(true, Flags.FLAG_ENABLE_OVERVIEW_COMMAND_HELPER_TIMEOUT)
 
+        setupDefaultDisplay()
+
         sut =
             spy(
                 OverviewCommandHelper(
                     touchInteractionService = mock(),
                     overviewComponentObserver = mock(),
-                    taskAnimationManager = mock(),
                     dispatcherProvider = TestDispatcherProvider(dispatcher),
-                    recentsDisplayModel = mock(),
+                    recentsDisplayModel = recentsDisplayModel,
                     focusState = mock(),
                     taskbarManager = mock(),
                 )
@@ -87,6 +108,8 @@
                         }
                     }
                 }
+                val commandInfo = invocation.arguments[0] as CommandInfo
+                executeCommandDisplayIds.add(commandInfo.displayId)
                 delayInMillis == null // if no callback to execute, returns success
             }
             .`when`(sut)
@@ -176,7 +199,61 @@
             assertThat(commandInfo2.status).isEqualTo(CommandStatus.COMPLETED)
         }
 
+    @Test
+    fun whenAllDisplaysCommandIsAdded_singleCommandProcessedForDefaultDisplay() =
+        testScope.runTest {
+            executeCommandDisplayIds.clear()
+            // Add command to queue
+            val commandInfo: CommandInfo = sut.addCommandsForAllDisplays(CommandType.HOME)!!
+            assertThat(commandInfo.status).isEqualTo(CommandStatus.IDLE)
+            runCurrent()
+            assertThat(commandInfo.status).isEqualTo(CommandStatus.COMPLETED)
+            assertThat(executeCommandDisplayIds).containsExactly(DEFAULT_DISPLAY)
+        }
+
+    @Test
+    fun whenAllDisplaysCommandIsAdded_multipleCommandsProcessedForMultipleDisplays() =
+        testScope.runTest {
+            setupMultipleDisplays()
+            executeCommandDisplayIds.clear()
+            // Add command to queue
+            val commandInfo: CommandInfo = sut.addCommandsForAllDisplays(CommandType.HOME)!!
+            assertThat(commandInfo.status).isEqualTo(CommandStatus.IDLE)
+            runCurrent()
+            assertThat(commandInfo.status).isEqualTo(CommandStatus.COMPLETED)
+            assertThat(executeCommandDisplayIds)
+                .containsExactly(DEFAULT_DISPLAY, EXTERNAL_DISPLAY_ID)
+        }
+
+    @Test
+    fun whenAllExceptDisplayCommandIsAdded_otherDisplayProcessed() =
+        testScope.runTest {
+            setupMultipleDisplays()
+            executeCommandDisplayIds.clear()
+            // Add command to queue
+            val commandInfo: CommandInfo =
+                sut.addCommandsForDisplaysExcept(CommandType.HOME, DEFAULT_DISPLAY)!!
+            assertThat(commandInfo.status).isEqualTo(CommandStatus.IDLE)
+            runCurrent()
+            assertThat(commandInfo.status).isEqualTo(CommandStatus.COMPLETED)
+            assertThat(executeCommandDisplayIds).containsExactly(EXTERNAL_DISPLAY_ID)
+        }
+
+    @Test
+    fun whenSingleDisplayCommandIsAdded_thatDisplayIsProcessed() =
+        testScope.runTest {
+            executeCommandDisplayIds.clear()
+            val displayId = 5
+            // Add command to queue
+            val commandInfo: CommandInfo = sut.addCommand(CommandType.HOME, displayId)!!
+            assertThat(commandInfo.status).isEqualTo(CommandStatus.IDLE)
+            runCurrent()
+            assertThat(commandInfo.status).isEqualTo(CommandStatus.COMPLETED)
+            assertThat(executeCommandDisplayIds).containsExactly(displayId)
+        }
+
     private companion object {
         const val QUEUE_TIMEOUT = 5001L
+        const val EXTERNAL_DISPLAY_ID = 1
     }
 }
diff --git a/quickstep/tests/multivalentTests/src/com/android/quickstep/RecentTasksListTest.java b/quickstep/tests/multivalentTests/src/com/android/quickstep/RecentTasksListTest.java
index 9722e9d..1e4315a 100644
--- a/quickstep/tests/multivalentTests/src/com/android/quickstep/RecentTasksListTest.java
+++ b/quickstep/tests/multivalentTests/src/com/android/quickstep/RecentTasksListTest.java
@@ -52,6 +52,7 @@
 import com.android.launcher3.statehandlers.DesktopVisibilityController;
 import com.android.launcher3.util.DaggerSingletonTracker;
 import com.android.launcher3.util.LooperExecutor;
+import com.android.quickstep.util.DesktopTask;
 import com.android.quickstep.util.GroupTask;
 import com.android.quickstep.views.TaskViewType;
 import com.android.systemui.shared.recents.model.Task;
@@ -148,6 +149,66 @@
     }
 
     @Test
+    @EnableFlags(FLAG_ENABLE_MULTIPLE_DESKTOPS_BACKEND)
+    public void loadTasksInBackground_freeformTask_multiDesksInMultiDisplays() throws Exception {
+        List<TaskInfo> tasksInDefaultDesk1 = Arrays.asList(
+                createRecentTaskInfo(/* taskId = */ 1, DEFAULT_DISPLAY),
+                createRecentTaskInfo(/* taskId = */ 4, DEFAULT_DISPLAY));
+        List<TaskInfo> tasksInDefaultDesk2 = Arrays.asList(
+                createRecentTaskInfo(/* taskId = */ 2, DEFAULT_DISPLAY),
+                createRecentTaskInfo(/* taskId = */ 3, DEFAULT_DISPLAY));
+        List<TaskInfo> tasksInExtend = Arrays.asList(
+                createRecentTaskInfo(/* taskId = */ 5, /* displayId = */ 1),
+                createRecentTaskInfo(/* taskId = */ 6, /* displayId = */ 1));
+        GroupedTaskInfo recentTaskInfosOfDesk1 = GroupedTaskInfo.forDeskTasks(/* deskId = */1,
+                DEFAULT_DISPLAY, tasksInDefaultDesk1, /* minimizedTaskIds = */
+                Collections.emptySet());
+        GroupedTaskInfo recentTaskInfosOfDesk2 = GroupedTaskInfo.forDeskTasks(/* deskId = */2,
+                DEFAULT_DISPLAY, tasksInDefaultDesk2, /* minimizedTaskIds = */
+                Collections.emptySet());
+        GroupedTaskInfo recentTaskInfosOfDesk3 = GroupedTaskInfo.forDeskTasks(/* deskId = */3,
+                /* displayId = */ 1, tasksInExtend, /* minimizedTaskIds = */
+                Collections.emptySet());
+        when(mSystemUiProxy.getRecentTasks(anyInt(), anyInt())).thenReturn(
+                new ArrayList<>(Arrays.asList(recentTaskInfosOfDesk1, recentTaskInfosOfDesk2,
+                        recentTaskInfosOfDesk3)));
+
+        List<GroupTask> taskList = mRecentTasksList.loadTasksInBackground(Integer.MAX_VALUE, -1,
+                false);
+
+        assertThat(taskList).hasSize(3);
+        assertThat(taskList.get(2).taskViewType).isEqualTo(TaskViewType.DESKTOP);
+        List<Task> actualFreeformTasksInDesk1 = taskList.get(2).getTasks();
+        assertThat(actualFreeformTasksInDesk1).hasSize(2);
+        assertThat(actualFreeformTasksInDesk1.get(0).key.id).isEqualTo(1);
+        assertThat(actualFreeformTasksInDesk1.get(0).isMinimized).isFalse();
+        assertThat(actualFreeformTasksInDesk1.get(1).key.id).isEqualTo(4);
+        assertThat(actualFreeformTasksInDesk1.get(1).isMinimized).isFalse();
+        assertThat(((DesktopTask) taskList.get(2)).getDeskId()).isEqualTo(1);
+        assertThat(((DesktopTask) taskList.get(2)).getDisplayId()).isEqualTo(DEFAULT_DISPLAY);
+
+        assertThat(taskList.get(1).taskViewType).isEqualTo(TaskViewType.DESKTOP);
+        List<Task> actualFreeformTasksInDesk2 = taskList.get(1).getTasks();
+        assertThat(actualFreeformTasksInDesk2).hasSize(2);
+        assertThat(actualFreeformTasksInDesk2.get(0).key.id).isEqualTo(2);
+        assertThat(actualFreeformTasksInDesk2.get(0).isMinimized).isFalse();
+        assertThat(actualFreeformTasksInDesk2.get(1).key.id).isEqualTo(3);
+        assertThat(actualFreeformTasksInDesk2.get(1).isMinimized).isFalse();
+        assertThat(((DesktopTask) taskList.get(1)).getDeskId()).isEqualTo(2);
+        assertThat(((DesktopTask) taskList.get(1)).getDisplayId()).isEqualTo(DEFAULT_DISPLAY);
+
+        assertThat(taskList.get(0).taskViewType).isEqualTo(TaskViewType.DESKTOP);
+        List<Task> actualFreeformTasksInDesk3 = taskList.get(0).getTasks();
+        assertThat(actualFreeformTasksInDesk3).hasSize(2);
+        assertThat(actualFreeformTasksInDesk3.get(0).key.id).isEqualTo(5);
+        assertThat(actualFreeformTasksInDesk3.get(0).isMinimized).isFalse();
+        assertThat(actualFreeformTasksInDesk3.get(1).key.id).isEqualTo(6);
+        assertThat(actualFreeformTasksInDesk3.get(1).isMinimized).isFalse();
+        assertThat(((DesktopTask) taskList.get(0)).getDeskId()).isEqualTo(3);
+        assertThat(((DesktopTask) taskList.get(0)).getDisplayId()).isEqualTo(1);
+    }
+
+    @Test
     public void loadTasksInBackground_moreThanKeys_hasValidTaskDescription() throws Exception  {
         String taskDescription = "Wheeee!";
         RecentTaskInfo task1 = new RecentTaskInfo();
@@ -175,7 +236,8 @@
     }
 
     @Test
-    @DisableFlags(FLAG_ENABLE_SEPARATE_EXTERNAL_DISPLAY_TASKS)
+    @DisableFlags({FLAG_ENABLE_SEPARATE_EXTERNAL_DISPLAY_TASKS,
+            FLAG_ENABLE_MULTIPLE_DESKTOPS_BACKEND})
     public void loadTasksInBackground_freeformTask_createsDesktopTask() throws Exception  {
         List<TaskInfo> tasks = Arrays.asList(
                 createRecentTaskInfo(1 /* taskId */, DEFAULT_DISPLAY),
@@ -183,7 +245,8 @@
                 createRecentTaskInfo(5 /* taskId */, 1 /* displayId */),
                 createRecentTaskInfo(6 /* taskId */, 1 /* displayId */));
         GroupedTaskInfo recentTaskInfos = GroupedTaskInfo.forDeskTasks(
-                0 /* deskId */, tasks, Collections.emptySet() /* minimizedTaskIds */);
+                0 /* deskId */, DEFAULT_DISPLAY, tasks,
+                Collections.emptySet() /* minimizedTaskIds */);
         when(mSystemUiProxy.getRecentTasks(anyInt(), anyInt()))
                 .thenReturn(new ArrayList<>(Collections.singletonList(recentTaskInfos)));
 
@@ -214,7 +277,8 @@
                 createRecentTaskInfo(5 /* taskId */, 1 /* displayId */),
                 createRecentTaskInfo(6 /* taskId */, 1 /* displayId */));
         GroupedTaskInfo recentTaskInfos = GroupedTaskInfo.forDeskTasks(
-                0 /* deskId */, tasks, Collections.emptySet() /* minimizedTaskIds */);
+                0 /* deskId */, DEFAULT_DISPLAY, tasks,
+                Collections.emptySet() /* minimizedTaskIds */);
         when(mSystemUiProxy.getRecentTasks(anyInt(), anyInt()))
                 .thenReturn(new ArrayList<>(Collections.singletonList(recentTaskInfos)));
 
@@ -248,7 +312,7 @@
         Set<Integer> minimizedTaskIds =
                 Arrays.stream(new Integer[]{1, 4, 5}).collect(Collectors.toSet());
         GroupedTaskInfo recentTaskInfos = GroupedTaskInfo.forDeskTasks(
-                0 /* deskId */, tasks, minimizedTaskIds);
+                0 /* deskId */, DEFAULT_DISPLAY, tasks, minimizedTaskIds);
         when(mSystemUiProxy.getRecentTasks(anyInt(), anyInt()))
                 .thenReturn(new ArrayList<>(Collections.singletonList(recentTaskInfos)));
 
diff --git a/quickstep/tests/multivalentTests/src/com/android/quickstep/TaskAnimationManagerTest.java b/quickstep/tests/multivalentTests/src/com/android/quickstep/TaskAnimationManagerTest.java
index 6e9885a..fd88a5c 100644
--- a/quickstep/tests/multivalentTests/src/com/android/quickstep/TaskAnimationManagerTest.java
+++ b/quickstep/tests/multivalentTests/src/com/android/quickstep/TaskAnimationManagerTest.java
@@ -26,6 +26,7 @@
 import android.app.ActivityOptions;
 import android.content.Context;
 import android.content.Intent;
+import android.view.Display;
 
 import androidx.test.ext.junit.runners.AndroidJUnit4;
 import androidx.test.filters.SmallTest;
@@ -54,7 +55,7 @@
     public void setUp() {
         MockitoAnnotations.initMocks(this);
         mTaskAnimationManager = new TaskAnimationManager(mContext,
-                RecentsAnimationDeviceState.INSTANCE.get(mContext)) {
+                RecentsAnimationDeviceState.INSTANCE.get(mContext), Display.DEFAULT_DISPLAY) {
             @Override
             SystemUiProxy getSystemUiProxy() {
                 return mSystemUiProxy;
diff --git a/quickstep/tests/multivalentTests/src/com/android/quickstep/orientation/LandscapePagedViewHandlerTest.kt b/quickstep/tests/multivalentTests/src/com/android/quickstep/orientation/LandscapePagedViewHandlerTest.kt
index 0570c26..66b3b04 100644
--- a/quickstep/tests/multivalentTests/src/com/android/quickstep/orientation/LandscapePagedViewHandlerTest.kt
+++ b/quickstep/tests/multivalentTests/src/com/android/quickstep/orientation/LandscapePagedViewHandlerTest.kt
@@ -43,12 +43,12 @@
         if (isEnabled) {
             setFlagsRule.enableFlags(
                 Flags.FLAG_ENABLE_GRID_ONLY_OVERVIEW,
-                Flags.FLAG_ENABLE_OVERVIEW_ICON_MENU
+                Flags.FLAG_ENABLE_OVERVIEW_ICON_MENU,
             )
         } else {
             setFlagsRule.disableFlags(
                 Flags.FLAG_ENABLE_GRID_ONLY_OVERVIEW,
-                Flags.FLAG_ENABLE_OVERVIEW_ICON_MENU
+                Flags.FLAG_ENABLE_OVERVIEW_ICON_MENU,
             )
         }
     }
@@ -108,14 +108,8 @@
 
         val (topLeftY, bottomRightY) = getSplitIconsPosition(isRTL = true)
 
-        // TODO(b/326377497): When started in fake seascape and rotated to landscape,
-        //  the icon chips are in RTL and wrongly positioned at the right side of the snapshot.
-        //  Top-Left app chip should be placed at the top left of the first snapshot, but because
-        //  this issue, it's displayed at the top-right of the second snapshot.
-        //  The Bottom-Right app chip is displayed at the top-right of the first snapshot because
-        //  of this issue.
-        assertThat(topLeftY).isEqualTo(0)
-        assertThat(bottomRightY).isEqualTo(-316)
+        assertThat(topLeftY).isEqualTo(-316)
+        assertThat(bottomRightY).isEqualTo(0)
     }
 
     /** Test updateSplitIconsPosition */
diff --git a/quickstep/tests/multivalentTests/src/com/android/quickstep/orientation/SeascapePagedViewHandlerTest.kt b/quickstep/tests/multivalentTests/src/com/android/quickstep/orientation/SeascapePagedViewHandlerTest.kt
index 3788688..d455b0d 100644
--- a/quickstep/tests/multivalentTests/src/com/android/quickstep/orientation/SeascapePagedViewHandlerTest.kt
+++ b/quickstep/tests/multivalentTests/src/com/android/quickstep/orientation/SeascapePagedViewHandlerTest.kt
@@ -43,12 +43,12 @@
         if (isEnabled) {
             setFlagsRule.enableFlags(
                 Flags.FLAG_ENABLE_GRID_ONLY_OVERVIEW,
-                Flags.FLAG_ENABLE_OVERVIEW_ICON_MENU
+                Flags.FLAG_ENABLE_OVERVIEW_ICON_MENU,
             )
         } else {
             setFlagsRule.disableFlags(
                 Flags.FLAG_ENABLE_GRID_ONLY_OVERVIEW,
-                Flags.FLAG_ENABLE_OVERVIEW_ICON_MENU
+                Flags.FLAG_ENABLE_OVERVIEW_ICON_MENU,
             )
         }
     }
@@ -110,12 +110,6 @@
 
         val (topLeftY, bottomRightY) = getSplitIconsPosition(isRTL = true)
 
-        // TODO(b/326377497): When started in fake seascape and rotated to landscape,
-        //  the icon chips are in RTL and wrongly positioned at the right side of the snapshot.
-        //  Top-Left app chip should be placed at the top left of the first snapshot, but because
-        //  this issue, it's displayed at the top-right of the second snapshot.
-        //  The Bottom-Right app chip is displayed at the top-right of the first snapshot because
-        //  of this issue.
         assertThat(topLeftY).isEqualTo(316)
         assertThat(bottomRightY).isEqualTo(0)
     }
@@ -167,7 +161,7 @@
         `when`(iconView.layoutParams).thenReturn(frameLayout)
 
         sut.updateSplitIconsPosition(iconView, expectedTranslationY, false)
-        assertThat(frameLayout.gravity).isEqualTo(Gravity.BOTTOM or Gravity.START)
+        assertThat(frameLayout.gravity).isEqualTo(Gravity.BOTTOM or Gravity.END)
         verify(iconView).setSplitTranslationX(0f)
         verify(iconView).setSplitTranslationY(expectedTranslationY.toFloat())
     }
@@ -182,7 +176,7 @@
         `when`(iconView.layoutParams).thenReturn(frameLayout)
 
         sut.updateSplitIconsPosition(iconView, expectedTranslationY, true)
-        assertThat(frameLayout.gravity).isEqualTo(Gravity.TOP or Gravity.END)
+        assertThat(frameLayout.gravity).isEqualTo(Gravity.TOP or Gravity.START)
         verify(iconView).setSplitTranslationX(0f)
         verify(iconView).setSplitTranslationY(expectedTranslationY.toFloat())
     }
diff --git a/quickstep/tests/multivalentTests/src/com/android/quickstep/recents/data/TasksRepositoryTest.kt b/quickstep/tests/multivalentTests/src/com/android/quickstep/recents/data/TasksRepositoryTest.kt
index 6790567..e22892c 100644
--- a/quickstep/tests/multivalentTests/src/com/android/quickstep/recents/data/TasksRepositoryTest.kt
+++ b/quickstep/tests/multivalentTests/src/com/android/quickstep/recents/data/TasksRepositoryTest.kt
@@ -21,6 +21,7 @@
 import android.graphics.Bitmap
 import android.graphics.Rect
 import android.graphics.drawable.Drawable
+import android.view.Display.DEFAULT_DISPLAY
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import com.android.launcher3.util.SplitConfigurationOptions
 import com.android.launcher3.util.TestDispatcherProvider
@@ -64,7 +65,7 @@
                     /* snapPosition = */ SNAP_TO_2_50_50,
                 ),
             ),
-            DesktopTask(deskId = 0, tasks.subList(3, 6)),
+            DesktopTask(deskId = 0, DEFAULT_DISPLAY, tasks.subList(3, 6)),
         )
     private val recentsModel = FakeRecentTasksDataSource()
     private val taskThumbnailDataSource = FakeTaskThumbnailDataSource()
diff --git a/quickstep/tests/multivalentTests/src/com/android/quickstep/recents/domain/usecase/GetThumbnailPositionUseCaseTest.kt b/quickstep/tests/multivalentTests/src/com/android/quickstep/recents/domain/usecase/GetThumbnailPositionUseCaseTest.kt
index a253280..7646e69 100644
--- a/quickstep/tests/multivalentTests/src/com/android/quickstep/recents/domain/usecase/GetThumbnailPositionUseCaseTest.kt
+++ b/quickstep/tests/multivalentTests/src/com/android/quickstep/recents/domain/usecase/GetThumbnailPositionUseCaseTest.kt
@@ -25,11 +25,14 @@
 import com.android.quickstep.recents.data.FakeRecentsRotationStateRepository
 import com.android.systemui.shared.recents.model.ThumbnailData
 import com.android.systemui.shared.recents.utilities.PreviewPositionHelper
+import com.android.systemui.shared.recents.utilities.PreviewPositionHelper.PreviewPositionHelperFactory
 import com.google.common.truth.Truth.assertThat
 import kotlinx.coroutines.test.runTest
+import org.junit.Before
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.mockito.kotlin.mock
+import org.mockito.kotlin.times
 import org.mockito.kotlin.verify
 import org.mockito.kotlin.whenever
 
@@ -38,15 +41,21 @@
 class GetThumbnailPositionUseCaseTest {
     private val deviceProfileRepository = FakeRecentsDeviceProfileRepository()
     private val rotationStateRepository = FakeRecentsRotationStateRepository()
+    private val previewPositionHelperFactoryMock = mock<PreviewPositionHelperFactory>()
     private val previewPositionHelper = mock<PreviewPositionHelper>()
 
     private val systemUnderTest =
         GetThumbnailPositionUseCase(
-            deviceProfileRepository,
-            rotationStateRepository,
-            previewPositionHelper,
+            deviceProfileRepository = deviceProfileRepository,
+            rotationStateRepository = rotationStateRepository,
+            previewPositionHelperFactory = previewPositionHelperFactoryMock,
         )
 
+    @Before
+    fun setUp() {
+        whenever(previewPositionHelperFactoryMock.create()).thenReturn(previewPositionHelper)
+    }
+
     @Test
     fun nullThumbnailData_returnsIdentityMatrix() = runTest {
         val expectedResult = ThumbnailPosition(Matrix.IDENTITY_MATRIX, false)
@@ -96,6 +105,25 @@
             )
     }
 
+    @Test
+    fun multipleInvocations_usesPreviewPositionHelperFactoryEachTime() = runTest {
+        whenever(previewPositionHelper.matrix).thenReturn(MATRIX)
+
+        val sut =
+            GetThumbnailPositionUseCase(
+                deviceProfileRepository = deviceProfileRepository,
+                rotationStateRepository = rotationStateRepository,
+                previewPositionHelperFactory = previewPositionHelperFactoryMock,
+            )
+        verify(previewPositionHelperFactoryMock, times(0)).create()
+
+        sut.invoke(THUMBNAIL_DATA, CANVAS_WIDTH, CANVAS_HEIGHT, /* isRtl= */ true)
+        sut.invoke(THUMBNAIL_DATA, CANVAS_WIDTH, CANVAS_HEIGHT, /* isRtl= */ false)
+
+        // Each invocation of use case should use a fresh position helper acquired by the factory.
+        verify(previewPositionHelperFactoryMock, times(2)).create()
+    }
+
     private companion object {
         const val THUMBNAIL_WIDTH = 100
         const val THUMBNAIL_HEIGHT = 200
diff --git a/quickstep/tests/multivalentTests/src/com/android/quickstep/recents/ui/mapper/TaskUiStateMapperTest.kt b/quickstep/tests/multivalentTests/src/com/android/quickstep/recents/ui/mapper/TaskUiStateMapperTest.kt
index b49923f..6c0d0ed 100644
--- a/quickstep/tests/multivalentTests/src/com/android/quickstep/recents/ui/mapper/TaskUiStateMapperTest.kt
+++ b/quickstep/tests/multivalentTests/src/com/android/quickstep/recents/ui/mapper/TaskUiStateMapperTest.kt
@@ -19,7 +19,9 @@
 import android.graphics.Bitmap
 import android.graphics.Color
 import android.graphics.drawable.ShapeDrawable
+import android.platform.test.annotations.DisableFlags
 import android.platform.test.annotations.EnableFlags
+import android.platform.test.flag.junit.SetFlagsRule
 import android.view.Surface
 import android.view.View
 import androidx.test.ext.junit.runners.AndroidJUnit4
@@ -31,12 +33,15 @@
 import com.android.quickstep.task.thumbnail.TaskThumbnailUiState.Snapshot
 import com.android.systemui.shared.recents.model.ThumbnailData
 import com.google.common.truth.Truth.assertThat
+import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
 
 @RunWith(AndroidJUnit4::class)
 class TaskUiStateMapperTest {
 
+    @get:Rule val mSetFlagsRule = SetFlagsRule()
+
     /** TaskHeaderUiState */
     @Test
     fun taskData_isNull_returns_HideHeader() {
@@ -49,6 +54,29 @@
         assertThat(result).isEqualTo(TaskHeaderUiState.HideHeader)
     }
 
+    @DisableFlags(Flags.FLAG_ENABLE_DESKTOP_EXPLODED_VIEW)
+    @Test
+    fun explodedFlagDisabled_returnsHideHeader() {
+        val inputs =
+            listOf(
+                TASK_DATA,
+                TASK_DATA.copy(thumbnailData = null),
+                TASK_DATA.copy(isLocked = true),
+                TASK_DATA.copy(title = null),
+            )
+        val closeCallback = View.OnClickListener {}
+        val expected = TaskHeaderUiState.HideHeader
+        inputs.forEach { taskData ->
+            val result =
+                TaskUiStateMapper.toTaskHeaderState(
+                    taskData = taskData,
+                    hasHeader = true,
+                    clickCloseListener = closeCallback,
+                )
+            assertThat(result).isEqualTo(expected)
+        }
+    }
+
     @EnableFlags(Flags.FLAG_ENABLE_DESKTOP_EXPLODED_VIEW)
     @Test
     fun taskData_hasHeader_and_taskData_returnsShowHeader() {
diff --git a/quickstep/tests/multivalentTests/src/com/android/quickstep/util/DesktopTaskTest.kt b/quickstep/tests/multivalentTests/src/com/android/quickstep/util/DesktopTaskTest.kt
index 6fbf482..15da4d4 100644
--- a/quickstep/tests/multivalentTests/src/com/android/quickstep/util/DesktopTaskTest.kt
+++ b/quickstep/tests/multivalentTests/src/com/android/quickstep/util/DesktopTaskTest.kt
@@ -18,6 +18,7 @@
 
 import android.content.ComponentName
 import android.content.Intent
+import android.view.Display.DEFAULT_DISPLAY
 import com.android.launcher3.util.LauncherMultivalentJUnit
 import com.android.systemui.shared.recents.model.Task
 import com.google.common.truth.Truth.assertThat
@@ -29,42 +30,42 @@
 
     @Test
     fun testDesktopTask_sameInstance_isEqual() {
-        val task = DesktopTask(deskId = 0, createTasks(1))
+        val task = DesktopTask(deskId = 0, DEFAULT_DISPLAY, createTasks(1))
         assertThat(task).isEqualTo(task)
     }
 
     @Test
     fun testDesktopTask_identicalConstructor_isEqual() {
-        val task1 = DesktopTask(deskId = 0, createTasks(1))
-        val task2 = DesktopTask(deskId = 0, createTasks(1))
+        val task1 = DesktopTask(deskId = 0, DEFAULT_DISPLAY, createTasks(1))
+        val task2 = DesktopTask(deskId = 0, DEFAULT_DISPLAY, createTasks(1))
         assertThat(task1).isEqualTo(task2)
     }
 
     @Test
     fun testDesktopTask_copy_isEqual() {
-        val task1 = DesktopTask(deskId = 0, createTasks(1))
+        val task1 = DesktopTask(deskId = 0, DEFAULT_DISPLAY, createTasks(1))
         val task2 = task1.copy()
         assertThat(task1).isEqualTo(task2)
     }
 
     @Test
     fun testDesktopTask_differentDeskIds_isNotEqual() {
-        val task1 = DesktopTask(deskId = 0, createTasks(1))
-        val task2 = DesktopTask(deskId = 1, createTasks(1))
+        val task1 = DesktopTask(deskId = 0, DEFAULT_DISPLAY, createTasks(1))
+        val task2 = DesktopTask(deskId = 1, DEFAULT_DISPLAY, createTasks(1))
         assertThat(task1).isNotEqualTo(task2)
     }
 
     @Test
     fun testDesktopTask_differentTaskIds_isNotEqual() {
-        val task1 = DesktopTask(deskId = 0, createTasks(1))
-        val task2 = DesktopTask(deskId = 0, createTasks(2))
+        val task1 = DesktopTask(deskId = 0, DEFAULT_DISPLAY, createTasks(1))
+        val task2 = DesktopTask(deskId = 0, DEFAULT_DISPLAY, createTasks(2))
         assertThat(task1).isNotEqualTo(task2)
     }
 
     @Test
     fun testDesktopTask_differentLength_isNotEqual() {
-        val task1 = DesktopTask(deskId = 0, createTasks(1))
-        val task2 = DesktopTask(deskId = 0, createTasks(1, 2))
+        val task1 = DesktopTask(deskId = 0, DEFAULT_DISPLAY, createTasks(1))
+        val task2 = DesktopTask(deskId = 0, DEFAULT_DISPLAY, createTasks(1, 2))
         assertThat(task1).isNotEqualTo(task2)
     }
 
diff --git a/quickstep/tests/multivalentTests/src/com/android/quickstep/util/GroupTaskTest.kt b/quickstep/tests/multivalentTests/src/com/android/quickstep/util/GroupTaskTest.kt
index 67fc62f..9f49171 100644
--- a/quickstep/tests/multivalentTests/src/com/android/quickstep/util/GroupTaskTest.kt
+++ b/quickstep/tests/multivalentTests/src/com/android/quickstep/util/GroupTaskTest.kt
@@ -19,6 +19,7 @@
 import android.content.ComponentName
 import android.content.Intent
 import android.graphics.Rect
+import android.view.Display.DEFAULT_DISPLAY
 import com.android.launcher3.util.LauncherMultivalentJUnit
 import com.android.launcher3.util.SplitConfigurationOptions
 import com.android.systemui.shared.recents.model.Task
@@ -98,7 +99,7 @@
     @Test
     fun testGroupTask_differentType_isNotEqual() {
         val task1 = SingleTask(createTask(1))
-        val task2 = DesktopTask(deskId = 0, listOf(createTask(1)))
+        val task2 = DesktopTask(deskId = 0, DEFAULT_DISPLAY, listOf(createTask(1)))
         assertThat(task1).isNotEqualTo(task2)
     }
 
diff --git a/quickstep/tests/src/com/android/quickstep/DesktopSystemShortcutTest.kt b/quickstep/tests/src/com/android/quickstep/DesktopSystemShortcutTest.kt
index 7b73be7..746f8bb 100644
--- a/quickstep/tests/src/com/android/quickstep/DesktopSystemShortcutTest.kt
+++ b/quickstep/tests/src/com/android/quickstep/DesktopSystemShortcutTest.kt
@@ -22,6 +22,7 @@
 import android.content.pm.PackageManager
 import android.platform.test.annotations.DisableFlags
 import android.platform.test.annotations.EnableFlags
+import android.platform.test.flag.junit.SetFlagsRule
 import android.view.Display.DEFAULT_DISPLAY
 import androidx.test.platform.app.InstrumentationRegistry
 import com.android.dx.mockito.inline.extended.ExtendedMockito.mockitoSession
@@ -52,6 +53,7 @@
 import com.google.common.truth.Truth.assertThat
 import org.junit.After
 import org.junit.Before
+import org.junit.Rule
 import org.junit.Test
 import org.mockito.Mockito.`when`
 import org.mockito.kotlin.any
@@ -64,8 +66,11 @@
 import org.mockito.quality.Strictness
 
 /** Test for [DesktopSystemShortcut] */
+// TODO(b/403558856): Improve test coverage for DesktopModeCompatPolicy integration.
 class DesktopSystemShortcutTest {
 
+    @get:Rule val setFlagsRule = SetFlagsRule(SetFlagsRule.DefaultInitValueType.DEVICE_DEFAULT)
+
     private val launcher: RecentsViewContainer = mock()
     private val statsLogManager: StatsLogManager = mock()
     private val statsLogger: StatsLogManager.StatsLogger = mock()
diff --git a/quickstep/tests/src/com/android/quickstep/InputConsumerUtilsTest.java b/quickstep/tests/src/com/android/quickstep/InputConsumerUtilsTest.java
index ef6f55e..93b979c 100644
--- a/quickstep/tests/src/com/android/quickstep/InputConsumerUtilsTest.java
+++ b/quickstep/tests/src/com/android/quickstep/InputConsumerUtilsTest.java
@@ -27,7 +27,6 @@
 import static org.mockito.Mockito.when;
 
 import android.annotation.NonNull;
-import android.annotation.Nullable;
 import android.os.Looper;
 import android.view.Choreographer;
 import android.view.Display;
@@ -100,12 +99,13 @@
 
     @Rule public final SandboxApplication mContext = new SandboxApplication();
 
+    private final int mDisplayId = Display.DEFAULT_DISPLAY;
     @NonNull private final InputMonitorCompat mInputMonitorCompat =
-            new InputMonitorCompat("", Display.DEFAULT_DISPLAY);
+            new InputMonitorCompat("", mDisplayId);
 
     private TaskAnimationManager mTaskAnimationManager;
     private InputChannelCompat.InputEventReceiver mInputEventReceiver;
-    @Nullable private ResetGestureInputConsumer mResetGestureInputConsumer;
+    private boolean mUserUnlocked = true;
     @NonNull private Function<GestureState, AnimatedFloat> mSwipeUpProxyProvider = (state) -> null;
 
     @NonNull @Mock private TaskbarActivityContext mTaskbarActivityContext;
@@ -126,8 +126,7 @@
 
     @Before
     public void setupTaskAnimationManager() {
-        mTaskAnimationManager = new TaskAnimationManager(
-                mContext, mDeviceState);
+        mTaskAnimationManager = new TaskAnimationManager(mContext, mDeviceState, mDisplayId);
     }
 
     @Before
@@ -164,12 +163,6 @@
     }
 
     @Before
-    public void setUpResetGestureInputConsumer() {
-        mResetGestureInputConsumer = new ResetGestureInputConsumer(
-                mTaskAnimationManager, mTaskbarManager::getCurrentActivityContext);
-    }
-
-    @Before
     public void setupLockedUserState() {
         when(mLockedUserState.isUserUnlocked()).thenReturn(true);
     }
@@ -314,8 +307,6 @@
 
     @Test
     public void testNewBaseConsumer_containsOtherActivityInputConsumer() {
-        // OtherActivityInputConsumer needs to be initialized on the main thread because of
-        // MotionPauseDetector.mForcePauseTimeout
         assertCorrectInputConsumer(
                 this::createBaseInputConsumer,
                 OtherActivityInputConsumer.class,
@@ -486,7 +477,7 @@
         MotionEvent event = MotionEvent.obtain(0, 0, MotionEvent.ACTION_DOWN, 0, 0, 0);
         InputConsumer inputConsumer = newConsumer(
                 mContext,
-                mResetGestureInputConsumer,
+                mUserUnlocked,
                 mOverviewComponentObserver,
                 mDeviceState,
                 mPreviousGestureState,
@@ -510,7 +501,8 @@
         MotionEvent event = MotionEvent.obtain(0, 0, MotionEvent.ACTION_DOWN, 0, 0, 0);
         InputConsumer inputConsumer = newBaseConsumer(
                 mContext,
-                mResetGestureInputConsumer,
+                mUserUnlocked,
+                mTaskbarManager,
                 mOverviewComponentObserver,
                 mDeviceState,
                 mPreviousGestureState,
@@ -535,12 +527,15 @@
                 ResetGestureInputConsumer.class,
                 InputConsumer.TYPE_RESET_GESTURE);
 
-        mResetGestureInputConsumer = null;
+        mUserUnlocked = false;
 
-        runOnMainSync(() -> assertThat(inputConsumerProvider.get()).isEqualTo(InputConsumer.NO_OP));
+        assertCorrectInputConsumer(
+                inputConsumerProvider,
+                InputConsumer.class,
+                InputConsumer.TYPE_NO_OP);
     }
 
-    private static void assertCorrectInputConsumer(
+    private void assertCorrectInputConsumer(
             @NonNull Provider<InputConsumer> inputConsumerProvider,
             @NonNull Class<? extends InputConsumer> expectedOutputConsumer,
             int expectedType) {
@@ -551,11 +546,13 @@
                 expectedType);
     }
 
-    private static void assertCorrectInputConsumer(
+    private void assertCorrectInputConsumer(
             @NonNull Provider<InputConsumer> inputConsumerProvider,
             @NonNull Class<? extends InputConsumer> expectedOutputConsumer,
             @NonNull Class<? extends InputConsumer> expectedActiveConsumer,
             int expectedType) {
+        when(mCurrentGestureState.getDisplayId()).thenReturn(mDisplayId);
+
         runOnMainSync(() -> {
             InputConsumer inputConsumer = inputConsumerProvider.get();
 
@@ -563,7 +560,14 @@
             assertThat(inputConsumer.getActiveConsumerInHierarchy())
                     .isInstanceOf(expectedActiveConsumer);
             assertThat(inputConsumer.getType()).isEqualTo(expectedType);
+            assertThat(inputConsumer.getDisplayId()).isEqualTo(mDisplayId);
         });
+        int expectedDisplayId = mDisplayId + 1;
+
+        when(mCurrentGestureState.getDisplayId()).thenReturn(expectedDisplayId);
+
+        runOnMainSync(() -> assertThat(inputConsumerProvider.get().getDisplayId())
+                .isEqualTo(expectedDisplayId));
     }
 
     private static void runOnMainSync(@NonNull Runnable runnable) {
diff --git a/quickstep/tests/src/com/android/quickstep/desktop/DesktopAppLaunchAnimatorHelperTest.kt b/quickstep/tests/src/com/android/quickstep/desktop/DesktopAppLaunchAnimatorHelperTest.kt
index 47108e0..daa77d2 100644
--- a/quickstep/tests/src/com/android/quickstep/desktop/DesktopAppLaunchAnimatorHelperTest.kt
+++ b/quickstep/tests/src/com/android/quickstep/desktop/DesktopAppLaunchAnimatorHelperTest.kt
@@ -32,7 +32,9 @@
 import android.view.SurfaceControl
 import android.view.WindowManager
 import android.window.TransitionInfo
+import android.window.TransitionInfo.Change
 import androidx.core.util.Supplier
+import androidx.test.internal.runner.junit4.statement.UiThreadStatement.runOnUiThread
 import com.android.app.animation.Interpolators
 import com.android.internal.jank.Cuj
 import com.android.launcher3.desktop.DesktopAppLaunchAnimatorHelper
@@ -45,6 +47,7 @@
 import org.junit.Test
 import org.mockito.kotlin.any
 import org.mockito.kotlin.mock
+import org.mockito.kotlin.verify
 import org.mockito.kotlin.whenever
 
 class DesktopAppLaunchAnimatorHelperTest {
@@ -70,6 +73,10 @@
         whenever(transactionSupplier.get()).thenReturn(transaction)
         whenever(transaction.setCrop(any(), any())).thenReturn(transaction)
         whenever(transaction.setCornerRadius(any(), any())).thenReturn(transaction)
+        whenever(transaction.setScale(any(), any(), any())).thenReturn(transaction)
+        whenever(transaction.setPosition(any(), any(), any())).thenReturn(transaction)
+        whenever(transaction.setAlpha(any(), any())).thenReturn(transaction)
+        whenever(transaction.setFrameTimeline(any())).thenReturn(transaction)
 
         whenever(context.resources).thenReturn(resources)
         whenever(resources.displayMetrics).thenReturn(DisplayMetrics())
@@ -77,14 +84,8 @@
     }
 
     @Test
-    fun launchTransition_returnsLaunchAnimator() {
-        val openChange =
-            TransitionInfo.Change(mock(), mock()).apply {
-                mode = WindowManager.TRANSIT_OPEN
-                taskInfo = TASK_INFO_FREEFORM
-            }
-        val transitionInfo = TransitionInfo(WindowManager.TRANSIT_NONE, 0)
-        transitionInfo.addChange(openChange)
+    fun launchTransition_returnsLaunchAnimator() = runOnUiThread {
+        val transitionInfo = createTransitionInfo(listOf(OPEN_CHANGE))
 
         val actual = helper.createAnimators(transitionInfo, finishCallback = {})
 
@@ -93,14 +94,27 @@
     }
 
     @Test
-    fun noLaunchTransition_returnsEmptyAnimatorsList() {
+    fun launchTransition_callsAnimationEndListener() = runOnUiThread {
+        val finishCallback = mock<Function1<Animator, Unit>>()
+        val transitionInfo = createTransitionInfo(listOf(OPEN_CHANGE))
+
+        val animators = helper.createAnimators(transitionInfo, finishCallback = finishCallback)
+
+        animators.forEach { animator ->
+            animator.start()
+            animator.end()
+            verify(finishCallback).invoke(animator)
+        }
+    }
+
+    @Test
+    fun noLaunchTransition_returnsEmptyAnimatorsList() = runOnUiThread {
         val pipChange =
             TransitionInfo.Change(mock(), mock()).apply {
                 mode = WindowManager.TRANSIT_PIP
                 taskInfo = TASK_INFO_FREEFORM
             }
-        val transitionInfo = TransitionInfo(WindowManager.TRANSIT_NONE, 0)
-        transitionInfo.addChange(pipChange)
+        val transitionInfo = createTransitionInfo(listOf(pipChange))
 
         val actual = helper.createAnimators(transitionInfo, finishCallback = {})
 
@@ -108,20 +122,8 @@
     }
 
     @Test
-    fun minimizeTransition_returnsLaunchAndMinimizeAnimator() {
-        val openChange =
-            TransitionInfo.Change(mock(), mock()).apply {
-                mode = WindowManager.TRANSIT_OPEN
-                taskInfo = TASK_INFO_FREEFORM
-            }
-        val minimizeChange =
-            TransitionInfo.Change(mock(), mock()).apply {
-                mode = WindowManager.TRANSIT_TO_BACK
-                taskInfo = TASK_INFO_FREEFORM
-            }
-        val transitionInfo = TransitionInfo(WindowManager.TRANSIT_NONE, 0)
-        transitionInfo.addChange(openChange)
-        transitionInfo.addChange(minimizeChange)
+    fun minimizeTransition_returnsLaunchAndMinimizeAnimator() = runOnUiThread {
+        val transitionInfo = createTransitionInfo(listOf(OPEN_CHANGE, MINIMIZE_CHANGE))
 
         val actual = helper.createAnimators(transitionInfo, finishCallback = {})
 
@@ -131,21 +133,23 @@
     }
 
     @Test
+    fun minimizeTransition_callsAnimationEndListener() = runOnUiThread {
+        val finishCallback = mock<Function1<Animator, Unit>>()
+        val transitionInfo = createTransitionInfo(listOf(OPEN_CHANGE, MINIMIZE_CHANGE))
+
+        val animators = helper.createAnimators(transitionInfo, finishCallback = finishCallback)
+
+        animators.forEach { animator ->
+            animator.start()
+            animator.end()
+            verify(finishCallback).invoke(animator)
+        }
+    }
+
+    @Test
     @EnableFlags(Flags.FLAG_ENABLE_DESKTOP_TRAMPOLINE_CLOSE_ANIMATION_BUGFIX)
-    fun trampolineTransition_flagEnabled_returnsLaunchAndCloseAnimator() {
-        val openChange =
-            TransitionInfo.Change(mock(), mock()).apply {
-                mode = WindowManager.TRANSIT_OPEN
-                taskInfo = TASK_INFO_FREEFORM
-            }
-        val closeChange =
-            TransitionInfo.Change(mock(), mock()).apply {
-                mode = WindowManager.TRANSIT_CLOSE
-                taskInfo = TASK_INFO_FREEFORM
-            }
-        val transitionInfo = TransitionInfo(WindowManager.TRANSIT_NONE, 0)
-        transitionInfo.addChange(openChange)
-        transitionInfo.addChange(closeChange)
+    fun trampolineTransition_flagEnabled_returnsLaunchAndCloseAnimator() = runOnUiThread {
+        val transitionInfo = createTransitionInfo(listOf(OPEN_CHANGE, CLOSE_CHANGE))
 
         val actual = helper.createAnimators(transitionInfo, finishCallback = {})
 
@@ -155,21 +159,24 @@
     }
 
     @Test
+    @EnableFlags(Flags.FLAG_ENABLE_DESKTOP_TRAMPOLINE_CLOSE_ANIMATION_BUGFIX)
+    fun trampolineTransition_flagEnabled_callsAnimationEndListener() = runOnUiThread {
+        val finishCallback = mock<Function1<Animator, Unit>>()
+        val transitionInfo = createTransitionInfo(listOf(OPEN_CHANGE, CLOSE_CHANGE))
+
+        val animators = helper.createAnimators(transitionInfo, finishCallback = finishCallback)
+
+        animators.forEach { animator ->
+            animator.start()
+            animator.end()
+            verify(finishCallback).invoke(animator)
+        }
+    }
+
+    @Test
     @DisableFlags(Flags.FLAG_ENABLE_DESKTOP_TRAMPOLINE_CLOSE_ANIMATION_BUGFIX)
-    fun trampolineTransition_flagDisabled_returnsLaunchAnimator() {
-        val openChange =
-            TransitionInfo.Change(mock(), mock()).apply {
-                mode = WindowManager.TRANSIT_OPEN
-                taskInfo = TASK_INFO_FREEFORM
-            }
-        val closeChange =
-            TransitionInfo.Change(mock(), mock()).apply {
-                mode = WindowManager.TRANSIT_CLOSE
-                taskInfo = TASK_INFO_FREEFORM
-            }
-        val transitionInfo = TransitionInfo(WindowManager.TRANSIT_NONE, 0)
-        transitionInfo.addChange(openChange)
-        transitionInfo.addChange(closeChange)
+    fun trampolineTransition_flagDisabled_returnsLaunchAnimator() = runOnUiThread {
+        val transitionInfo = createTransitionInfo(listOf(OPEN_CHANGE, CLOSE_CHANGE))
 
         val actual = helper.createAnimators(transitionInfo, finishCallback = {})
 
@@ -179,26 +186,9 @@
 
     @Test
     @EnableFlags(Flags.FLAG_ENABLE_DESKTOP_TRAMPOLINE_CLOSE_ANIMATION_BUGFIX)
-    fun trampolineTransition_flagEnabled_hitDesktopWindowLimit_returnsLaunchMinimizeCloseAnimator() {
-        val openChange =
-            TransitionInfo.Change(mock(), mock()).apply {
-                mode = WindowManager.TRANSIT_OPEN
-                taskInfo = TASK_INFO_FREEFORM
-            }
-        val minimizeChange =
-            TransitionInfo.Change(mock(), mock()).apply {
-                mode = WindowManager.TRANSIT_TO_BACK
-                taskInfo = TASK_INFO_FREEFORM
-            }
-        val closeChange =
-            TransitionInfo.Change(mock(), mock()).apply {
-                mode = WindowManager.TRANSIT_CLOSE
-                taskInfo = TASK_INFO_FREEFORM
-            }
-        val transitionInfo = TransitionInfo(WindowManager.TRANSIT_NONE, 0)
-        transitionInfo.addChange(openChange)
-        transitionInfo.addChange(minimizeChange)
-        transitionInfo.addChange(closeChange)
+    fun trampolineTransition_flagEnabled_hitDesktopWindowLimit_returnsLaunchMinimizeCloseAnimator() = runOnUiThread {
+        val transitionInfo = createTransitionInfo(
+            listOf(OPEN_CHANGE, MINIMIZE_CHANGE, CLOSE_CHANGE))
 
         val actual = helper.createAnimators(transitionInfo, finishCallback = {})
 
@@ -210,26 +200,9 @@
 
     @Test
     @DisableFlags(Flags.FLAG_ENABLE_DESKTOP_TRAMPOLINE_CLOSE_ANIMATION_BUGFIX)
-    fun trampolineTransition_flagDisabled_hitDesktopWindowLimit_returnsLaunchMinimizeAnimator() {
-        val openChange =
-            TransitionInfo.Change(mock(), mock()).apply {
-                mode = WindowManager.TRANSIT_OPEN
-                taskInfo = TASK_INFO_FREEFORM
-            }
-        val minimizeChange =
-            TransitionInfo.Change(mock(), mock()).apply {
-                mode = WindowManager.TRANSIT_TO_BACK
-                taskInfo = TASK_INFO_FREEFORM
-            }
-        val closeChange =
-            TransitionInfo.Change(mock(), mock()).apply {
-                mode = WindowManager.TRANSIT_CLOSE
-                taskInfo = TASK_INFO_FREEFORM
-            }
-        val transitionInfo = TransitionInfo(WindowManager.TRANSIT_NONE, 0)
-        transitionInfo.addChange(openChange)
-        transitionInfo.addChange(minimizeChange)
-        transitionInfo.addChange(closeChange)
+    fun trampolineTransition_flagDisabled_hitDesktopWindowLimit_returnsLaunchMinimizeAnimator() = runOnUiThread {
+        val transitionInfo = createTransitionInfo(
+            listOf(OPEN_CHANGE, MINIMIZE_CHANGE, CLOSE_CHANGE))
 
         val actual = helper.createAnimators(transitionInfo, finishCallback = {})
 
@@ -280,6 +253,12 @@
         assertThat(animator.duration).isEqualTo(100)
     }
 
+    private fun createTransitionInfo(changes: List<Change>): TransitionInfo {
+        val transitionInfo = TransitionInfo(WindowManager.TRANSIT_NONE, 0)
+        changes.forEach { transitionInfo.addChange(it) }
+        return transitionInfo
+    }
+
     private companion object {
         val TASK_INFO_FREEFORM =
             ActivityManager.RunningTaskInfo().apply {
@@ -290,5 +269,23 @@
                 configuration.windowConfiguration.windowingMode =
                     WindowConfiguration.WINDOWING_MODE_FREEFORM
             }
+
+        val OPEN_CHANGE =
+            TransitionInfo.Change(mock(), mock()).apply {
+                mode = WindowManager.TRANSIT_OPEN
+                taskInfo = TASK_INFO_FREEFORM
+            }
+
+        val CLOSE_CHANGE =
+            TransitionInfo.Change(mock(), mock()).apply {
+                mode = WindowManager.TRANSIT_CLOSE
+                taskInfo = TASK_INFO_FREEFORM
+            }
+
+        val MINIMIZE_CHANGE =
+            TransitionInfo.Change(mock(), mock()).apply {
+                mode = WindowManager.TRANSIT_TO_BACK
+                taskInfo = TASK_INFO_FREEFORM
+            }
     }
 }
diff --git a/quickstep/res/drawable/ic_chevron_end.xml b/res/drawable/ic_chevron_end.xml
similarity index 100%
rename from quickstep/res/drawable/ic_chevron_end.xml
rename to res/drawable/ic_chevron_end.xml
diff --git a/quickstep/res/drawable/ic_chevron_start.xml b/res/drawable/ic_chevron_start.xml
similarity index 100%
rename from quickstep/res/drawable/ic_chevron_start.xml
rename to res/drawable/ic_chevron_start.xml
diff --git a/res/drawable/ic_taskbar_all_apps_search_button_expressive_theme.xml b/res/drawable/ic_taskbar_all_apps_search_button_expressive_theme.xml
new file mode 100644
index 0000000..ed4a821
--- /dev/null
+++ b/res/drawable/ic_taskbar_all_apps_search_button_expressive_theme.xml
@@ -0,0 +1,25 @@
+<!--
+  ~ Copyright (C) 2025 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.
+  -->
+
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="52dp"
+    android:height="52dp"
+    android:viewportWidth="52"
+    android:viewportHeight="52">
+    <path
+        android:pathData="M32.862,38.75C31.263,38.75 29.888,38.175 28.737,37.025C27.587,35.875 27.013,34.487 27.013,32.862C27.013,31.237 27.587,29.85 28.737,28.7C29.888,27.55 31.263,26.975 32.862,26.975C34.487,26.975 35.875,27.55 37.025,28.7C38.175,29.85 38.75,31.237 38.75,32.862C38.75,33.438 38.662,33.987 38.487,34.513C38.338,35.037 38.125,35.525 37.85,35.975L41.45,39.612C41.6,39.737 41.7,39.875 41.75,40.025C41.825,40.175 41.862,40.338 41.862,40.513C41.862,40.688 41.825,40.85 41.75,41C41.7,41.15 41.6,41.3 41.45,41.45C41.325,41.575 41.188,41.675 41.037,41.75C40.888,41.8 40.725,41.825 40.55,41.825C40.375,41.825 40.213,41.8 40.063,41.75C39.912,41.675 39.763,41.575 39.612,41.45L35.975,37.85C35.525,38.15 35.037,38.375 34.513,38.525C33.987,38.675 33.438,38.75 32.862,38.75ZM16.1,38.75C14.5,38.75 13.125,38.175 11.975,37.025C10.825,35.875 10.25,34.5 10.25,32.9C10.25,31.25 10.825,29.85 11.975,28.7C13.125,27.55 14.5,26.975 16.1,26.975C17.75,26.975 19.15,27.55 20.3,28.7C21.45,29.85 22.025,31.25 22.025,32.9C22.025,34.5 21.45,35.875 20.3,37.025C19.15,38.175 17.75,38.75 16.1,38.75ZM32.862,36.125C33.763,36.125 34.525,35.813 35.15,35.188C35.8,34.537 36.125,33.775 36.125,32.9C36.125,31.975 35.8,31.2 35.15,30.575C34.525,29.925 33.763,29.6 32.862,29.6C31.962,29.6 31.188,29.925 30.538,30.575C29.913,31.2 29.6,31.975 29.6,32.9C29.6,33.775 29.913,34.537 30.538,35.188C31.188,35.813 31.962,36.125 32.862,36.125ZM16.1,22.025C14.5,22.025 13.125,21.45 11.975,20.3C10.825,19.15 10.25,17.763 10.25,16.138C10.25,14.512 10.825,13.125 11.975,11.975C13.125,10.825 14.5,10.25 16.1,10.25C17.75,10.25 19.15,10.825 20.3,11.975C21.45,13.125 22.025,14.512 22.025,16.138C22.025,17.763 21.45,19.15 20.3,20.3C19.15,21.45 17.75,22.025 16.1,22.025ZM32.862,22.025C31.237,22.025 29.85,21.45 28.7,20.3C27.55,19.15 26.975,17.763 26.975,16.138C26.975,14.512 27.55,13.125 28.7,11.975C29.85,10.825 31.237,10.25 32.862,10.25C34.487,10.25 35.875,10.825 37.025,11.975C38.175,13.125 38.75,14.512 38.75,16.138C38.75,17.763 38.175,19.15 37.025,20.3C35.875,21.45 34.487,22.025 32.862,22.025Z"
+        android:fillColor="#FF000000"/>
+</vector>
\ No newline at end of file
diff --git a/res/layout/work_mode_utility_view.xml b/res/layout/work_mode_utility_view.xml
index b68ff3e..568c2c3 100644
--- a/res/layout/work_mode_utility_view.xml
+++ b/res/layout/work_mode_utility_view.xml
@@ -26,6 +26,7 @@
         android:layout_height="@dimen/work_scheduler_size"
         android:layout_marginBottom="@dimen/work_scheduler_bottom_margin"
         android:contentDescription="@string/work_scheduler_button_content_description"
+        android:elevation="@dimen/work_fab_elevation"
         android:src="@drawable/ic_schedule"
         android:layout_gravity="end"
         android:background="@drawable/work_scheduler_background" />
diff --git a/res/values-af/strings.xml b/res/values-af/strings.xml
index a2a1cf2..4133419 100644
--- a/res/values-af/strings.xml
+++ b/res/values-af/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"Bladsy %1$d van %2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"Tuisskerm %1$d van %2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"Nuwe tuisskermbladsy"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"Aktief"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"Geminimeer"</string>
     <string name="folder_opened" msgid="94695026776264709">"Vouer oopgemaak, <xliff:g id="WIDTH">%1$d</xliff:g> by <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"Tik om die vouer toe te maak"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"Tik om nuwe naam te stoor"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Muurpapier en styl"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Wysig tuisskerm"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Tuis-instellings"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Gedeaktiveer deur jou administrateur"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Laat toe dat tuisskerm gedraai word"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Wanneer foon gedraai word"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Kortpadkieslys"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Werk"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Persoonlike Apps-oortjie"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Werkapps-oortjie"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Werkprofiel"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Werkprogramme het \'n kenteken en is sigbaar vir jou IT-administrateur"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"Het dit"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Privaat Ruimte-oorgang"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Installeer"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Installeer apps in privaat ruimte"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-am/strings.xml b/res/values-am/strings.xml
index ac462ac..4cb4e1a 100644
--- a/res/values-am/strings.xml
+++ b/res/values-am/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"ገፅ %1$d ከ%2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"መነሻ ማያ ገፅ %1$d ከ%2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"አዲስ የመነሻ ማያ ገፅ"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"ገቢር"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"አንሷል"</string>
     <string name="folder_opened" msgid="94695026776264709">"አቃፊ ተከፍቷል፣ <xliff:g id="WIDTH">%1$d</xliff:g> በ<xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"አቃፊን ለመዝጋት መታ ያድርጉ"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"ዳግም የተሰጠውን ስም ለማስቀመጥ መታ ያድርጉ"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"ልጣፍ እና ቅጥ"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"መነሻ ማያ ገጽን አርትዕ"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"የመነሻ ቅንብሮች"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"በእርስዎ አስተዳዳሪ የተሰናከለ"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"የመነሻ ማያ ገፅ ማሽከርከርን ይፍቀዱ"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"ስልኩ ሲዞር"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"የአቋራጭ ምናሌ"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"አሰናብት"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"ዝጋ"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"የግል"</string>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"ሥራ"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"የግል መተግበሪያዎች ትር"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"የሥራ መተግበሪያዎች ትር"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"የሥራ መገለጫ"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"የሥራ መተግበሪያዎች ባጅ የተደረገባቸው እና ለእርስዎ የአይቲ አስተዳዳሪ የሚታዩ ናቸው"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"ገባኝ"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"የግል ቦታ ሽግግር"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"ይጫኑ"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"መተግበሪያዎችን ወደ የግል ቦታ ይጫኑ"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-ar/strings.xml b/res/values-ar/strings.xml
index 83b07ec..3961d11 100644
--- a/res/values-ar/strings.xml
+++ b/res/values-ar/strings.xml
@@ -131,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"الخلفية والأسلوب"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"تعديل الشاشة الرئيسية"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"إعدادات الشاشة الرئيسية"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"أوقف المشرف هذه الميزة"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"السماح بتدوير الشاشة الرئيسية"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"عند تدوير الهاتف"</string>
@@ -184,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"قائمة الاختصارات"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"تجاهل"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"إغلاق"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"شخصية"</string>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"للعمل"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"علامة تبويب التطبيقات الشخصية"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"علامة تبويب تطبيقات العمل"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"ملف العمل"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"تحمل تطبيقات العمل مميّزة بشارة ومرئية لمشرف تكنولوجيا المعلومات."</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"حسنًا"</string>
@@ -216,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"النقل إلى المساحة الخاصة"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"تثبيت"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"تثبيت التطبيقات في المساحة الخاصّة"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-as/strings.xml b/res/values-as/strings.xml
index 6db0ffb..b1b4113 100644
--- a/res/values-as/strings.xml
+++ b/res/values-as/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"%2$dৰ %1$d পৃষ্ঠা"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"গৃহ স্ক্ৰীন %2$dৰ %1$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"গৃহ স্ক্ৰীনৰ নতুন পৃষ্ঠা"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"সক্ৰিয়"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"মিনিমাইজ কৰা হৈছে"</string>
     <string name="folder_opened" msgid="94695026776264709">"ফ’ল্ডাৰ খোলা হ’ল, <xliff:g id="WIDTH">%1$d</xliff:g> x <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"ফ\'ল্ডাৰ বন্ধ কৰিবলৈ টিপক"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"সলনি কৰা নাম ছেভ কৰিবলৈ টিপক"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"ৱালপেপাৰ আৰু শৈলী"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"গৃহ স্ক্ৰীন সম্পাদনা কৰক"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"গৃহ ছেটিং"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"আপোনাৰ প্ৰশাসকে অক্ষম কৰি ৰাখিছে"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"গৃহ স্ক্ৰীন ঘূৰোৱাৰ অনুমতি দিয়ক"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"ফ\'নটো যেতিয়া ঘূৰোৱা হয়"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"শ্বৰ্টকাটৰ মেনু"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"অগ্ৰাহ্য কৰক"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"বন্ধ কৰক"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"ব্যক্তিগত"</string>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"কৰ্মস্থান"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"ব্যক্তিগত এপৰ টেব"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"কৰ্মস্থানৰ এপৰ টেব"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"কৰ্মস্থানৰ প্ৰ\'ফাইল"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"কৰ্মস্থানৰ এপ্‌সমূহ প্ৰতীকেৰে চিহ্নিত কৰা হয় আৰু সেইবোৰ আপোনাৰ আইটি প্ৰশাসকৰ বাবে দৃশ্যমান হয়"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"বুজি পালোঁ"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"ব্যক্তিগত স্পে’চৰ স্থানান্তৰণ"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"ইনষ্টল কৰক"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"এপ্‌সমূহ প্ৰাইভেট স্পেচত ইনষ্টল কৰক"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-az/strings.xml b/res/values-az/strings.xml
index 28035df..061b621 100644
--- a/res/values-az/strings.xml
+++ b/res/values-az/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"Səhifə %1$d of %2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"Əsas Səhifə ekranı %1$d of %2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"Yeni əsas ekran səhifəsi"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"Aktiv"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"Kiçildildi"</string>
     <string name="folder_opened" msgid="94695026776264709">"Qovluq açıldı, <xliff:g id="HEIGHT">%2$d</xliff:g> hündürlük ilə <xliff:g id="WIDTH">%1$d</xliff:g> enində"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"Qovluq bağlamaq üçün toxunun"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"Ad dəyişikliyini yadda saxlamaq üçün toxunun"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Divar kağızı və üslub"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Əsas ekranı redaktə edin"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Home ayarları"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Admininiz tərəfindən deaktiv edilib"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Əsas ekran çevrilsin"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Telefon çevrilən zaman"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Qısayol menyusu"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"İş"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Şəxsi tətbiqlər tabı"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"İş tətbiqləri tabı"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"İş profili"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"İş tətbiqləri nişanlanıb və İT administratorunuza görünür"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"Anladım"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Şəxsi məkana keçid"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Quraşdırın"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Tətbiqləri şəxsi sahədə quraşdırın"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-b+sr+Latn/strings.xml b/res/values-b+sr+Latn/strings.xml
index c8782e2..b53224a 100644
--- a/res/values-b+sr+Latn/strings.xml
+++ b/res/values-b+sr+Latn/strings.xml
@@ -131,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Pozadina i stil"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Izmeni početni ekran"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Podešavanja početnog ekrana"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Administrator je onemogućio"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Dozvoli rotaciju početnog ekrana"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Kada se telefon rotira"</string>
@@ -184,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Meni sa prečicama"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Posao"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Kartica Lične aplikacije"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Kartica Poslovne aplikacije"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Poslovni profil"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Poslovne aplikacije su označene značkom i IT administrator može da ih vidi"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"Važi"</string>
@@ -216,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Prenos privatnog prostora"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Instalirajte"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Instaliraj aplikacije u privatan prostor"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-be/strings.xml b/res/values-be/strings.xml
index ffb3d91..b12eb23 100644
--- a/res/values-be/strings.xml
+++ b/res/values-be/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"Старонка %1$d з %2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"Галоўны экран %1$d з %2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"Новая старонка галоўнага экрана"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"Актыўна"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"Згорнута"</string>
     <string name="folder_opened" msgid="94695026776264709">"Папка адкрыта, <xliff:g id="WIDTH">%1$d</xliff:g> на <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"Краніце, каб закрыць папку"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"Краніце, каб захаваць новую назву"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Шпалеры і стыль"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Змяніць Галоўны экран"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Налады галоўнага экрана"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Адключаная адміністратарам"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Дазволіць паварот галоўнага экрана"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Пры павароце тэлефона"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Меню спалучэнняў клавіш"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Адхіліць"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Закрыць"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Асабістыя"</string>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Працоўныя"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Укладка \"Асабістыя праграмы\""</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Укладка \"Працоўныя праграмы\""</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Працоўны профіль"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Працоўныя праграмы пазначаны спецыяльнымі значкамі, а таксама бачныя IT-адміністратару"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"Зразумела"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Пераход у прыватную вобласць"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Усталяваць"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Усталяваць праграмы ў прыватнай прасторы"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-bg/strings.xml b/res/values-bg/strings.xml
index a4c3faf..ee4dabc 100644
--- a/res/values-bg/strings.xml
+++ b/res/values-bg/strings.xml
@@ -131,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Тапет и стил"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Редактиране на началния екран"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Настройки за началния екран"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Деактивирано от администратора ви"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Разрешаване на завъртането на началния екран"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"При завъртане на телефона"</string>
@@ -184,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Меню за клавишните комбинации"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Отхвърляне"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Затваряне"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Лични"</string>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Служебни"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Раздел „Лични приложения“"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Раздел „Служебни приложения“"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Служебен потребителски профил"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Служебните приложения са означени със значка и са видими за системния администратор"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"Разбрах"</string>
@@ -216,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Преминаване към частното пространство"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Инсталиране"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Инсталиране на приложения в частно пространство"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-bn/strings.xml b/res/values-bn/strings.xml
index 6bc2483..a889a94 100644
--- a/res/values-bn/strings.xml
+++ b/res/values-bn/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"%2$dটির মধ্যে %1$dটি পৃষ্ঠা"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"%2$dটির %1$d নম্বর হোম স্ক্রিন"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"নতুন হোম স্ক্রীনের পৃষ্ঠা"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"অ্যাক্টিভ"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"ছোট করা হয়েছে"</string>
     <string name="folder_opened" msgid="94695026776264709">"ফোল্ডার খোলা হয়েছে, <xliff:g id="WIDTH">%1$d</xliff:g> বাই <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"ফোল্ডার বন্ধ করতে আলতো চাপ দিন"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"পুনঃনামকরণ সংরক্ষণ করতে আলতো চাপ দিন"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"ওয়ালপেপার এবং স্টাইল"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"হোম স্ক্রিন এডিট করুন"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"হোম সেটিংস"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"আপনার প্রশাসক দ্বারা অক্ষম করা হয়েছে"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"হোম স্ক্রিন রোটেট করার অনুমতি দিন"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"যখন ফোনটি ঘোরানো হয়"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"শর্টকাট মেনু"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"খারিজ করুন"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"বন্ধ করুন"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"ব্যক্তিগত"</string>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"অফিস"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"ব্যক্তিগত অ্যাপ সম্পর্কিত ট্যাব"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"অফিস অ্যাপ সম্পর্কিত ট্যাব"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"অফিসের প্রোফাইল"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"অফিস অ্যাপে ব্যাজ যোগ করা হয়েছে এবং আপনার আইটি অ্যাডমিন সেগুলি দেখতে পাবেন"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"বুঝেছি"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"ব্যক্তিগত স্পেস ট্রানজিট করা"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"ইনস্টল করুন"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"প্রাইভেট স্পেসে অ্যাপ ইনস্টল করুন"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-bs/strings.xml b/res/values-bs/strings.xml
index 394e30f..4308879 100644
--- a/res/values-bs/strings.xml
+++ b/res/values-bs/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"Strana %1$d od %2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"Početni ekran %1$d od %2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"Nova stranica početnog ekrana"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"Aktivno"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"Minimizirano"</string>
     <string name="folder_opened" msgid="94695026776264709">"Folder je otvoren, (š) <xliff:g id="WIDTH">%1$d</xliff:g> (v) <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"Dodirnite da zatvorite folder"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"Dodirnite da sačuvate promjenu naziva"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Pozadinska slika i stil"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Uredi Početni ekran"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Postavke početnog ekrana"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Onemogućio vaš administrator"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Dozvoli rotiranje početnog ekrana"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Kada se telefon zarotira"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Meni prečica"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Poslovno"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Kartica ličnih aplikacija"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Kartica poslovnih aplikacija"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Radni profil"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Poslovne aplikacije su označene i vaš IT administrator ih može vidjeti"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"Razumijem"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Prelazak u privatan prostor"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Instalirajte"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Instaliranje aplikacija u privatni prostor"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-ca/strings.xml b/res/values-ca/strings.xml
index 07a21ab..434117b 100644
--- a/res/values-ca/strings.xml
+++ b/res/values-ca/strings.xml
@@ -131,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Estil i fons de pantalla"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Edita la pantalla d\'inici"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Configuració de la pantalla d\'inici"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Desactivada per l\'administrador"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Permet la rotació de la pantalla d\'inici"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"En girar el telèfon"</string>
@@ -184,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Menú de dreceres"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Treball"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Pestanya Aplicacions personals"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Pestanya Aplicacions de treball"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Perfil de treball"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Les aplicacions de treball tenen una insígnia i el teu administrador de TI les pot veure"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"Entesos"</string>
@@ -216,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Canvia a Espai privat"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Instal·la"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Instal·la les aplicacions a Espai privat"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-cs/strings.xml b/res/values-cs/strings.xml
index 82bbd12..bc73d08 100644
--- a/res/values-cs/strings.xml
+++ b/res/values-cs/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"Strana %1$d z %2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"Plocha %1$d z %2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"Nová stránka plochy"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"Aktivní"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"Minimalizováno"</string>
     <string name="folder_opened" msgid="94695026776264709">"Složka otevřena, rozměry <xliff:g id="WIDTH">%1$d</xliff:g> x <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"Klepnutím složku zavřete"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"Klepnutím změnu názvu uložíte"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Tapety a styl"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Upravit plochu"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Nastavení plochy"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Zakázáno administrátorem"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Povolit otáčení plochy"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Při otočení telefonu"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Nabídka zkratek"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Pracovní"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Karta osobních aplikací"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Karta pracovních aplikací"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Pracovní profil"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Pracovní aplikace jsou označené a váš administrátor IT je vidí"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"Rozumím"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Převádění soukromého prostoru"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Nainstalovat"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Instalovat aplikace do soukromého prostoru"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-da/strings.xml b/res/values-da/strings.xml
index 1485f75..0a2f74f 100644
--- a/res/values-da/strings.xml
+++ b/res/values-da/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"Side %1$d ud af %2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"Startskærm %1$d ud af %2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"Ny startskærm"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"Aktiv"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"Minimeret"</string>
     <string name="folder_opened" msgid="94695026776264709">"Mappen er åben, <xliff:g id="WIDTH">%1$d</xliff:g> gange <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"Tryk for at lukke mappen"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"Tryk for at gemme omdøbningen"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Baggrund og stil"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Rediger startskærm"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Indst. for startskærm"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Deaktiveret af din administrator"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Tillad rotation af startskærmen"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Når telefonen roteres"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Genvejsmenu"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Arbejde"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Fanen Personlige apps"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Fanen Arbejdsapps"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Arbejdsprofil"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Arbejdsapps har badges og kan ses af din it-administrator"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"OK"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Ændringer af tilstanden for det private område"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Installer"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Installer apps i privat område"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-de/strings.xml b/res/values-de/strings.xml
index 4a7fb7f..69e1d90 100644
--- a/res/values-de/strings.xml
+++ b/res/values-de/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"Seite %1$d von %2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"Startbildschirm %1$d von %2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"Neue Startbildschirmseite"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"Aktiv"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"Minimiert"</string>
     <string name="folder_opened" msgid="94695026776264709">"Ordner geöffnet, <xliff:g id="WIDTH">%1$d</xliff:g> x <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"Ordner zum Schließen antippen"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"Neuen Namen zum Speichern antippen"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Hintergrund &amp; Stil"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Startbildschirm bearbeiten"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Einstellungen"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Von deinem Administrator deaktiviert"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Drehen des Startbildschirms zulassen"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Beim Drehen des Smartphones"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Menü für Tastenkombinationen"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Geschäftlich"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Tab „Private Apps“"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Tab „Geschäftliche Apps“"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Arbeitsprofil"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Geschäftliche Apps sind gekennzeichnet und für deinen IT-Administrator sichtbar"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"OK"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Sperrzustand des vertraulichen Profils wird gerade geändert"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Installieren"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Apps im vertraulichen Profil installieren"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-el/strings.xml b/res/values-el/strings.xml
index de2bdc7..aaa575c 100644
--- a/res/values-el/strings.xml
+++ b/res/values-el/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"Σελίδα %1$d από %2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"Αρχική οθόνη %1$d από %2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"Νέα σελίδα αρχικής οθόνης"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"Ενεργό"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"Ελαχιστοποιήθηκε"</string>
     <string name="folder_opened" msgid="94695026776264709">"Άνοιγμα φακέλου, <xliff:g id="WIDTH">%1$d</xliff:g> επί <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"Πατήστε για να κλείσετε το φάκελο"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"Πατήστε για να αποθηκεύσετε τη νέα ονομασία"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Ταπετσαρία και στιλ"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Επεξεργασία αρχικής οθόνης"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Ρυθμ. Αρχικής οθόνης"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Απενεργοποιήθηκε από τον διαχειριστή σας"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Να επιτρέπεται η περιστροφή της αρχικής οθόνης"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Όταν το τηλέφωνο περιστρέφεται"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Μενού συντομεύσεων"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Παράβλεψη"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Κλείσιμο"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Προσωπικές"</string>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Εργασίας"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Καρτέλα προσωπικών εφαρμογών"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Καρτέλα εφαρμογών εργασιών"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Προφίλ εργασίας"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Οι εφαρμογές εργασιών φέρουν σήμα και είναι ορατές στον διαχειριστή IT σας"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"Το κατάλαβα"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Μετάβαση στον Ιδιωτικό χώρο"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Εγκατάσταση"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Εγκατάσταση εφαρμογών στον ιδιωτικό χώρο"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-en-rAU/strings.xml b/res/values-en-rAU/strings.xml
index 7ce9c0c..db602e7 100644
--- a/res/values-en-rAU/strings.xml
+++ b/res/values-en-rAU/strings.xml
@@ -131,11 +131,13 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Wallpaper and style"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Edit home screen"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Home settings"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Disabled by your admin"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Allow home screen rotation"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"When phone is rotated"</string>
     <string name="landscape_mode_title" msgid="5138814555934843926">"Landscape mode"</string>
-    <string name="landscape_mode_desc" msgid="7372569859592816793">"Set phone into landscape mode"</string>
+    <string name="landscape_mode_desc" msgid="7372569859592816793">"Set phone to landscape mode"</string>
     <string name="notification_dots_title" msgid="9062440428204120317">"Notification dots"</string>
     <string name="notification_dots_desc_on" msgid="1679848116452218908">"On"</string>
     <string name="notification_dots_desc_off" msgid="1760796511504341095">"Off"</string>
@@ -184,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Shortcut menu"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Work"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Personal apps tab"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Work apps tab"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Work profile"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Work apps are badged and visible to your IT admin"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"OK"</string>
@@ -216,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Private Space transitioning"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Install"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Install apps to private space"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-en-rCA/strings.xml b/res/values-en-rCA/strings.xml
index 71fd15a..2756feb 100644
--- a/res/values-en-rCA/strings.xml
+++ b/res/values-en-rCA/strings.xml
@@ -131,6 +131,7 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Wallpaper and style"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Edit Home Screen"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Home settings"</string>
+    <string name="all_apps_home_screen" msgid="8658178652647896497">"Apps"</string>
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Disabled by your admin"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Allow home screen rotation"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"When phone is rotated"</string>
@@ -184,14 +185,14 @@
     <string name="action_decrease_height" msgid="282377193880900022">"Decrease height"</string>
     <string name="widget_resized" msgid="9130327887929620">"Widget resized to width <xliff:g id="NUMBER_0">%1$s</xliff:g> height <xliff:g id="NUMBER_1">%2$s</xliff:g>"</string>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Shortcut Menu"</string>
+    <string name="widget_frame_name" msgid="8782828448471444270">"Widget Resize Frame for <xliff:g id="STRING">%1$s</xliff:g>"</string>
+    <string name="action_close" msgid="1077760267194136901">"Close"</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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Work"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Personal apps tab"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Work apps tab"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Work profile"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Work apps are badged and visible to your IT admin"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"Got it"</string>
@@ -216,4 +217,5 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Private Space Transitioning"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Install"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Install apps to Private Space"</string>
+    <string name="ps_app_content_description" msgid="1129133475892816226">"Add files and more to Private Space"</string>
 </resources>
diff --git a/res/values-en-rGB/strings.xml b/res/values-en-rGB/strings.xml
index 7ce9c0c..db602e7 100644
--- a/res/values-en-rGB/strings.xml
+++ b/res/values-en-rGB/strings.xml
@@ -131,11 +131,13 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Wallpaper and style"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Edit home screen"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Home settings"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Disabled by your admin"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Allow home screen rotation"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"When phone is rotated"</string>
     <string name="landscape_mode_title" msgid="5138814555934843926">"Landscape mode"</string>
-    <string name="landscape_mode_desc" msgid="7372569859592816793">"Set phone into landscape mode"</string>
+    <string name="landscape_mode_desc" msgid="7372569859592816793">"Set phone to landscape mode"</string>
     <string name="notification_dots_title" msgid="9062440428204120317">"Notification dots"</string>
     <string name="notification_dots_desc_on" msgid="1679848116452218908">"On"</string>
     <string name="notification_dots_desc_off" msgid="1760796511504341095">"Off"</string>
@@ -184,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Shortcut menu"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Work"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Personal apps tab"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Work apps tab"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Work profile"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Work apps are badged and visible to your IT admin"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"OK"</string>
@@ -216,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Private Space transitioning"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Install"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Install apps to private space"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-en-rIN/strings.xml b/res/values-en-rIN/strings.xml
index 7ce9c0c..db602e7 100644
--- a/res/values-en-rIN/strings.xml
+++ b/res/values-en-rIN/strings.xml
@@ -131,11 +131,13 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Wallpaper and style"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Edit home screen"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Home settings"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Disabled by your admin"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Allow home screen rotation"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"When phone is rotated"</string>
     <string name="landscape_mode_title" msgid="5138814555934843926">"Landscape mode"</string>
-    <string name="landscape_mode_desc" msgid="7372569859592816793">"Set phone into landscape mode"</string>
+    <string name="landscape_mode_desc" msgid="7372569859592816793">"Set phone to landscape mode"</string>
     <string name="notification_dots_title" msgid="9062440428204120317">"Notification dots"</string>
     <string name="notification_dots_desc_on" msgid="1679848116452218908">"On"</string>
     <string name="notification_dots_desc_off" msgid="1760796511504341095">"Off"</string>
@@ -184,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Shortcut menu"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Work"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Personal apps tab"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Work apps tab"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Work profile"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Work apps are badged and visible to your IT admin"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"OK"</string>
@@ -216,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Private Space transitioning"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Install"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Install apps to private space"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-es-rUS/strings.xml b/res/values-es-rUS/strings.xml
index ef5d483..6dd87e1 100644
--- a/res/values-es-rUS/strings.xml
+++ b/res/values-es-rUS/strings.xml
@@ -131,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Fondo de pantalla y estilo"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Editar pantalla principal"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Configuración de pantalla principal"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"El administrador inhabilitó esta función"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Permitir la rotación de la pantalla principal"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Al girar el teléfono"</string>
@@ -184,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Menú de accesos directos"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Trabajo"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Pestaña de apps personales"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Pestaña de apps de trabajo"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Perfil de trabajo"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Las apps de trabajo tienen una insignia y el administrador de TI las puede ver"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"Entendido"</string>
@@ -216,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Pasar a Espacio privado"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Instalar"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Instala las apps en el espacio privado"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-es/strings.xml b/res/values-es/strings.xml
index a1ed2ed..c604da7 100644
--- a/res/values-es/strings.xml
+++ b/res/values-es/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"Página %1$d de %2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"Pantalla de inicio %1$d de %2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"Nueva página de pantalla de inicio"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"Activa"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"Minimizada"</string>
     <string name="folder_opened" msgid="94695026776264709">"Carpeta abierta, <xliff:g id="WIDTH">%1$d</xliff:g> por <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"Toca para cerrar la carpeta"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"Toca para guardar el nuevo nombre"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Fondo de pantalla y estilo"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Editar pantalla de inicio"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Ajustes de la pantalla de inicio"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Inhabilitado por el administrador"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Permitir rotación de la pantalla de inicio"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Al girar el teléfono"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Menú de combinaciones de teclas"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Trabajo"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Pestaña Aplicaciones personales"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Pestaña Aplicaciones de trabajo"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Perfil de trabajo"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Las aplicaciones de trabajo tienen una insignia, y tu administrador de TI las puede ver"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"Entendido"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Cambiar a espacio privado"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Instalar"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Descargar aplicaciones en el espacio privado"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-et/strings.xml b/res/values-et/strings.xml
index 5300ec8..3d270c9 100644
--- a/res/values-et/strings.xml
+++ b/res/values-et/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"Leht %1$d/%2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"Avakuva %1$d/%2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"Uus avakuva leht"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"Ühendatud"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"Minimeeritud"</string>
     <string name="folder_opened" msgid="94695026776264709">"Kaust on avatud, <xliff:g id="WIDTH">%1$d</xliff:g> x <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"Puudutage kausta sulgemiseks"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"Puudutage ümbernimetamise salvestamiseks"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Taustapilt ja stiil"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Muuda avaekraani"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Avakuva seaded"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Keelas administraator"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Luba avakuva pööramine"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Kui telefoni pööratakse"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Kiirmenüü"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Töö"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Vahekaart Isiklikud rakendused"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Vahekaart töörakendused"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Tööprofiil"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Töörakendustel on märk ja need on teie IT-administraatorile nähtavad"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"Selge"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Privaatse ruumi üleviimine"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Installi"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Rakenduste installimine privaatses ruumis"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-eu/strings.xml b/res/values-eu/strings.xml
index 013c88e..07a75a1 100644
--- a/res/values-eu/strings.xml
+++ b/res/values-eu/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"%1$d/%2$d orria"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"%1$d/%2$d orri nagusi"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"Orri nagusiaren orri berria"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"Aktibo"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"Minimizatuta"</string>
     <string name="folder_opened" msgid="94695026776264709">"Karpeta ireki da: <xliff:g id="WIDTH">%1$d</xliff:g> × <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"Karpeta ixteko, sakatu hau"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"Izen berria gordetzeko, sakatu hau"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Horma-papera eta estiloa"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Editatu orri nagusia"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Orri nagusiaren ezarpenak"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Administratzaileak desgaitu du"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Eman orri nagusia biratzeko baimena"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Telefonoa biratzean"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Lasterbideen menua"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Lanekoak"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Aplikazio pertsonalen fitxa"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Laneko aplikazioen fitxa"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Laneko profila"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Laneko aplikazioek bereizgarriak dituzte, eta IKT saileko administratzaileak ikus ditzake"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"Ados"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Eremu pribaturako trantsizioa"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Instalatu"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Instalatu aplikazioak eremu pribatuan"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-fa/strings.xml b/res/values-fa/strings.xml
index 578d35d..4afde8a 100644
--- a/res/values-fa/strings.xml
+++ b/res/values-fa/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"‏صفحه %1$d از %2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"‏صفحه اصلی %1$d از %2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"صفحه اصلی جدید"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"فعال"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"کوچک‌شده"</string>
     <string name="folder_opened" msgid="94695026776264709">"پوشه باز شده، <xliff:g id="WIDTH">%1$d</xliff:g> در <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"برای بستن پوشه، تک‌ضرب بزنید"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"برای ذخیره تغییر نام، تک‌ضرب بزنید"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"کاغذدیواری و سبک"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"ویرایش «صفحه اصلی»"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"تنظیمات صفحه اصلی"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"توسط سرپرست سیستم غیرفعال شده است"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"مجاز کردن چرخش صفحه اصلی"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"وقتی تلفن چرخانده می‌شود"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"منو میان‌بر"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"رد کردن"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"بستن"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"شخصی"</string>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"کاری"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"برگه برنامه‌های شخصی"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"برگه برنامه‌های کاری"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"نمایه کاری"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"برنامه‌های کاری نشان‌دار هستند و سرپرست فناوری اطلاعات می‌تواند آن‌ها را ببیند"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"متوجهم"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"انتقال «فضای خصوصی»"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"نصب"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"نصب برنامه‌ها در «فضای خصوصی»"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-fi/strings.xml b/res/values-fi/strings.xml
index 29d04b2..8a0de4c 100644
--- a/res/values-fi/strings.xml
+++ b/res/values-fi/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"Sivu %1$d / %2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"Aloitusruutu %1$d/%2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"Uusi aloitusnäytön sivu"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"Aktiivinen"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"Pienennetty"</string>
     <string name="folder_opened" msgid="94695026776264709">"Kansio avattu, koko <xliff:g id="WIDTH">%1$d</xliff:g> x <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"Sulje kansio koskettamalla."</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"Tallenna uusi nimi koskettamalla."</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Taustakuva ja tyyli"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Muokkaa aloitusnäyttöä"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Aloitusnäyttö"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Järjestelmänvalvoja on poistanut toiminnon käytöstä."</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Salli aloitusnäytön kiertäminen"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Kun puhelinta kierretään"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Pikanäppäinvalikko"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Työsovellukset"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Henkilökohtaiset sovellukset ‑välilehti"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Työsovellukset-välilehti"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Työprofiili"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Työsovellukset on merkitty sellaisiksi ja näkyvät IT-järjestelmänvalvojille"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"Selvä"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Yksityisen tilan siirtäminen"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Asenna"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Asenna sovelluksia yksityiseen tilaan"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-fr-rCA/strings.xml b/res/values-fr-rCA/strings.xml
index eb9360f..159d980 100644
--- a/res/values-fr-rCA/strings.xml
+++ b/res/values-fr-rCA/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"Page %1$d sur %2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"Écran d\'accueil %1$d sur %2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"Nouvelle page d\'écran d\'accueil"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"Actif"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"Réduit"</string>
     <string name="folder_opened" msgid="94695026776264709">"Dossier ouvert, <xliff:g id="WIDTH">%1$d</xliff:g> par <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"Touchez pour fermer le dossier"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"Touchez pour enregistrer le nouveau nom"</string>
@@ -133,11 +131,13 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Fond d\'écran et style"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Modifier l\'écran d\'accueil"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Paramètres d\'accueil"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Cette fonction est désactivée par votre administrateur"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Autoriser la rotation de l\'écran d\'accueil"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Lorsque vous faites pivoter le téléphone"</string>
     <string name="landscape_mode_title" msgid="5138814555934843926">"Mode paysage"</string>
-    <string name="landscape_mode_desc" msgid="7372569859592816793">"Configurer le téléphone en mode paysage"</string>
+    <string name="landscape_mode_desc" msgid="7372569859592816793">"Configurez le téléphone en mode paysage"</string>
     <string name="notification_dots_title" msgid="9062440428204120317">"Pastilles de notification"</string>
     <string name="notification_dots_desc_on" msgid="1679848116452218908">"Activé"</string>
     <string name="notification_dots_desc_off" msgid="1760796511504341095">"Désactivé"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Menu des raccourcis"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Travail"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Onglet Applis personnelles"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Onglet Applis professionnelles"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Profil professionnel"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Les applis professionnelles sont indiquées par un badge et elles sont visibles pour votre administrateur informatique"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"OK"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Transition vers l\'Espace privé"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Installer"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Installer des applis dans l\'Espace privé"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-fr/strings.xml b/res/values-fr/strings.xml
index fea7ff1..837425b 100644
--- a/res/values-fr/strings.xml
+++ b/res/values-fr/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"Page %1$d sur %2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"Écran d\'accueil %1$d sur %2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"Nouvelle page d\'écran d\'accueil"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"Actif"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"Minimisé"</string>
     <string name="folder_opened" msgid="94695026776264709">"Dossier ouvert, <xliff:g id="WIDTH">%1$d</xliff:g> par <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"Appuyez pour fermer le dossier."</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"Appuyez pour enregistrer le nouveau nom du dossier."</string>
@@ -133,11 +131,13 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Fond d\'écran et style"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Modifier l\'écran d\'accueil"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Paramètres de l\'accueil"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Désactivé par votre administrateur"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Autoriser la rotation de l\'écran d\'accueil"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Lorsque vous faites pivoter le téléphone"</string>
     <string name="landscape_mode_title" msgid="5138814555934843926">"Mode Paysage"</string>
-    <string name="landscape_mode_desc" msgid="7372569859592816793">"Placez le téléphone en mode Paysage"</string>
+    <string name="landscape_mode_desc" msgid="7372569859592816793">"Paramétrer le téléphone en mode Paysage"</string>
     <string name="notification_dots_title" msgid="9062440428204120317">"Pastilles de notification"</string>
     <string name="notification_dots_desc_on" msgid="1679848116452218908">"Activées"</string>
     <string name="notification_dots_desc_off" msgid="1760796511504341095">"Désactivées"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Menu de raccourci"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Professionnel"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Onglet \"Applications personnelles\""</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Onglet \"Applications professionnelles\""</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Profil professionnel"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Les applis professionnelles sont identifiées par un badge et votre administrateur informatique peut les voir"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"OK"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Transition vers Espace privé"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Installer"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Installer des applis dans l\'espace privé"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-gl/strings.xml b/res/values-gl/strings.xml
index 513083a..5c9b179 100644
--- a/res/values-gl/strings.xml
+++ b/res/values-gl/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"Páxina %1$d de %2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"Pantalla de inicio %1$d de %2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"Nova páxina da pantalla de inicio"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"Activa"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"Minimizada"</string>
     <string name="folder_opened" msgid="94695026776264709">"Abriuse o cartafol, <xliff:g id="WIDTH">%1$d</xliff:g> por <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"Toca fóra para pechar o cartafol"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"Toca fóra para cambiar o nome do cartafol"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Estilo e fondo de pantalla"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Editar pantalla de inicio"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Configuración da pantalla de inicio"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Función desactivada polo administrador"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Permitir xirar a pantalla de inicio"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Ao xirar o teléfono"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Menú do atallo"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Traballo"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Pestana de aplicacións persoais"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Pestana de aplicacións do traballo"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Perfil de traballo"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"O administrador de TI pode ver as aplicacións do traballo e engadirlles indicadores"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"Entendido"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Transición ao espazo privado"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Instalar"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Instalar as aplicacións no espazo privado"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-gu/strings.xml b/res/values-gu/strings.xml
index d31f291..5f9407b 100644
--- a/res/values-gu/strings.xml
+++ b/res/values-gu/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"%2$d માંથી %1$d પૃષ્ઠ"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"%2$d માંથી %1$d હોમ સ્ક્રીન"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"નવું હોમ સ્ક્રીન પૃષ્ઠ"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"સક્રિય"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"ન્યૂનતમ"</string>
     <string name="folder_opened" msgid="94695026776264709">"<xliff:g id="WIDTH">%1$d</xliff:g> બાય <xliff:g id="HEIGHT">%2$d</xliff:g> નું ફોલ્ડર ખોલ્યું"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"ફોલ્ડર બંધ કરવા માટે ટૅપ કરો"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"નામ બદલવાનું સાચવવા માટે ટૅપ કરો"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"વૉલપેપર અને સ્ટાઇલ"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"હોમ સ્ક્રીનમાં ફેરફાર કરો"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"હોમ સેટિંગ"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"તમારા વ્યવસ્થાપક દ્વારા અક્ષમ કરેલ"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"હોમ સ્ક્રીનને ફેરવવાની મંજૂરી આપો"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"જ્યારે ફોન ફેરવવામાં આવે ત્યારે"</string>
@@ -186,6 +186,10 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"શૉર્ટકટ મેનૂ"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"છોડી દો"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"બંધ કરો"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"વ્યક્તિગત ઍપ"</string>
@@ -218,4 +222,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"ખાનગી સ્પેસ પર સ્થાનાંતરણ"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"ઇન્સ્ટૉલ કરો"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"ખાનગી સ્પેસમાં ઍપ ઇન્સ્ટૉલ કરો"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-hi/strings.xml b/res/values-hi/strings.xml
index 360ef33..5bd0c6f 100644
--- a/res/values-hi/strings.xml
+++ b/res/values-hi/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"पेज %2$d में से %1$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"होम स्क्रीन %2$d में से %1$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"नया होम स्‍क्रीन पेज"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"चालू है"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"छोटा किया गया"</string>
     <string name="folder_opened" msgid="94695026776264709">"फ़ोल्डर खोला गया, <xliff:g id="WIDTH">%1$d</xliff:g> गुणा <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"फ़ोल्डर बंद करने के लिए टैप करें"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"नाम बदलना सहेजने के लिए टैप करें"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"वॉलपेपर और स्टाइल"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"होम स्क्रीन में बदलाव करें"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"होम स्क्रीन की सेटिंग"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"आपके एडमिन ने बंद किया हुआ है"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"होम स्क्रीन घुमाने की अनुमति दें"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"फ़ोन घुुमाए जाने पर"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"शॉर्टकट मेन्यू"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"खारिज करें"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"बंद करें"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"निजी ऐप्लिकेशन"</string>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"वर्क ऐप्लिकेशन"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"निजी ऐप्लिकेशन टैब"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"वर्क ऐप्लिकेशन टैब"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"वर्क प्रोफ़ाइल"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"वर्क ऐप्लिकेशन बैज किए गए हैं. आईटी एडमिन इन्हें देख सकता है"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"ठीक है"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"प्राइवेट स्पेस की सेटिंग में बदलाव किया जा रहा है"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"इंस्टॉल करें"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"प्राइवेट स्पेस में ऐप्लिकेशन इंस्टॉल करें"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-hr/strings.xml b/res/values-hr/strings.xml
index db82c46..6ff7441 100644
--- a/res/values-hr/strings.xml
+++ b/res/values-hr/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"Stranica %1$d od %2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"Početni zaslon %1$d od %2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"Nova stranica početnog zaslona"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"Aktivno"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"Minimizirano"</string>
     <string name="folder_opened" msgid="94695026776264709">"Mapa je otvorena, <xliff:g id="WIDTH">%1$d</xliff:g> x <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"Dodirnite da biste zatvorili mapu"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"Dodirnite da biste spremili promijenjeni naziv"</string>
@@ -133,11 +131,13 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Pozadina i stil"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Uredi početni zaslon"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Postavke početnog zaslona"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Onemogućio administrator"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Dopusti zakretanje početnog zaslona"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Kada se telefon zakrene"</string>
     <string name="landscape_mode_title" msgid="5138814555934843926">"Pejzažni način"</string>
-    <string name="landscape_mode_desc" msgid="7372569859592816793">"Postavljanje telefona u pejzažni način"</string>
+    <string name="landscape_mode_desc" msgid="7372569859592816793">"Telefon se postavlja u pejzažni način"</string>
     <string name="notification_dots_title" msgid="9062440428204120317">"Točke obavijesti"</string>
     <string name="notification_dots_desc_on" msgid="1679848116452218908">"Uključeno"</string>
     <string name="notification_dots_desc_off" msgid="1760796511504341095">"Isključeno"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Izbornik prečaca"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Posao"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Kartica osobnih aplikacija"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Kartica poslovnih aplikacija"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Poslovni profil"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Poslovne su aplikacije označene i vidljive vašem IT administratoru"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"Shvaćam"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Prelazak na privatni prostor"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Instalirajte"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Instaliranje aplikacija u privatni prostor"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-hu/strings.xml b/res/values-hu/strings.xml
index 04e43a7..5920dff 100644
--- a/res/values-hu/strings.xml
+++ b/res/values-hu/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"%2$d/%1$d. oldal"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"%2$d/%1$d. kezdőképernyő"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"Új kezdőképernyő oldal"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"Aktív"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"Kis méret"</string>
     <string name="folder_opened" msgid="94695026776264709">"Mappa megnyitva – szélesség: <xliff:g id="WIDTH">%1$d</xliff:g>; magasság: <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"Érintse meg a mappa bezárásához"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"Koppintson ide az átnevezés mentéséhez"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Háttérkép és stílus"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Kezdőképernyő szerkesztése"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Kezdőképernyő beállításai"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"A rendszergazda letiltotta"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"A kezdőképernyő elforgatásának engedélyezése"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"A telefon elforgatásakor"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Gyorsparancsok menüje"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Munkahelyi"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Személyes alkalmazások lap"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Munkahelyi alkalmazások lap"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Munkaprofil"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"A munkahelyi alkalmazások jelvénnyel vannak megjelölve, és ezeket láthatja a rendszergazda"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"Értem"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Átállás privát területre…"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Telepítés"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Alkalmazások telepítése privát területre"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-hy/strings.xml b/res/values-hy/strings.xml
index 7d805a6..38e0bf1 100644
--- a/res/values-hy/strings.xml
+++ b/res/values-hy/strings.xml
@@ -131,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Պաստառ և ոճ"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Փոփոխել հիմնական էկրանը"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Գլխավոր էկրանի կարգավորումներ"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Անջատվել է ձեր ադմինիստրատորի կողմից"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Թույլ տալ հիմնական էկրանի պտտումը"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Հեռախոսը պտտելու դեպքում"</string>
@@ -184,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Դյուրանցման ընտրացանկ"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Անտեսել"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Փակել"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Անձնական"</string>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Աշխատանքային"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Անձնական հավելվածների ներդիր"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Աշխատանքային հավելվածների ներդիր"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Աշխատանքային պրոֆիլ"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Աշխատանքային հավելվածները հատուկ նշանակ ունեն և տեսանելի են ՏՏ ադմինիստրատորին"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"Եղավ"</string>
@@ -216,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Անցում մասնավոր տարածք"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Տեղադրել"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Հավելվածների տեղադրում անձնական տարածքում"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-in/strings.xml b/res/values-in/strings.xml
index 28a01ac..a850e9c 100644
--- a/res/values-in/strings.xml
+++ b/res/values-in/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"Halaman %1$d dari %2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"Layar utama %1$d dari %2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"Halaman layar utama baru"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"Aktif"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"Diperkecil"</string>
     <string name="folder_opened" msgid="94695026776264709">"Folder dibuka, <xliff:g id="WIDTH">%1$d</xliff:g> x <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"Ketuk untuk menutup folder"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"Ketuk untuk menyimpan ganti nama"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Wallpaper &amp; gaya"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Edit Layar Utama"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Setelan layar utama"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Dinonaktifkan oleh admin"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Izinkan layar utama diputar"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Saat ponsel diputar"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Menu Pintasan"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Kerja"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Tab aplikasi pribadi"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Tab aplikasi kerja"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Profil kerja"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Aplikasi kerja diberi badge dan terlihat oleh admin IT"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"Oke"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Ruang Pribadi Bertransisi"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Instal"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Instal aplikasi ke Ruang Pribadi"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-is/strings.xml b/res/values-is/strings.xml
index a87df93..0dbcda2 100644
--- a/res/values-is/strings.xml
+++ b/res/values-is/strings.xml
@@ -131,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Veggfóður og stíll"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Breyta heimaskjá"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Heimastillingar"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Gert óvirkt af kerfisstjóra"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Leyfa snúning á heimaskjá"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Þegar símanum er snúið"</string>
@@ -184,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Flýtileiðavalmynd"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Vinna"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Flipi forrita til einkanota"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Flipi vinnuforrita"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Vinnusnið"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Vinnuforrit eru merkt og kerfisstjórinn getur séð þau"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"Ég skil"</string>
@@ -216,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Leynirými að breytast"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Setja upp"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Setja upp forrit í leynirými"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-it/strings.xml b/res/values-it/strings.xml
index ffe7436..29e28e1 100644
--- a/res/values-it/strings.xml
+++ b/res/values-it/strings.xml
@@ -131,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Sfondo e stile"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Modifica schermata Home"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Impostazioni schermata Home"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Disattivata dall\'amministratore"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Consenti rotazione della schermata Home"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Con il telefono ruotato"</string>
@@ -184,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Menu scorciatoie"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Lavoro"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Scheda App personali"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Scheda App di lavoro"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Profilo di lavoro"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Le app di lavoro sono contrassegnate con un badge e visibili all\'amministratore IT"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"OK"</string>
@@ -216,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Transizione dello Spazio privato in corso…"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Installa"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Installa le app su spazi privati"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-iw/strings.xml b/res/values-iw/strings.xml
index dd496c8..1d3eef1 100644
--- a/res/values-iw/strings.xml
+++ b/res/values-iw/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"‏דף %1$d מתוך %2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"‏מסך הבית %1$d מתוך %2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"מסך הבית חדש"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"פעיל"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"ממוזער"</string>
     <string name="folder_opened" msgid="94695026776264709">"תיקייה פתוחה, <xliff:g id="WIDTH">%1$d</xliff:g> על <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"יש ללחוץ כדי לסגור את התיקייה"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"יש ללחוץ כדי לשמור שינוי שם"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"טפט וסגנון"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"עריכה של מסך הבית"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"הגדרות של מסך הבית"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"הושבת על ידי מנהל המערכת שלך"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"סיבוב מסך הבית"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"כאשר מסובבים את הטלפון"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"תפריט קיצורי הדרך"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"סגירה"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"סגירה"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"אישי"</string>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"עבודה"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"הכרטיסייה \"אפליקציות לשימוש אישי\""</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"הכרטיסייה \"אפליקציות לעבודה\""</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"פרופיל עבודה"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"‏האפליקציות לעבודה מתויגות ומוצגות למנהל ה-IT"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"הבנתי"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"מעבר למרחב הפרטי"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"התקנה"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"התקנת אפליקציות במרחב הפרטי"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-ja/strings.xml b/res/values-ja/strings.xml
index 9000081..9cc6a83 100644
--- a/res/values-ja/strings.xml
+++ b/res/values-ja/strings.xml
@@ -131,11 +131,13 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"壁紙とスタイル"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"ホーム画面を編集"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"ホームの設定"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"管理者により無効にされています"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"ホーム画面の回転を許可"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"スマートフォンの向きに合わせます"</string>
     <string name="landscape_mode_title" msgid="5138814555934843926">"横表示"</string>
-    <string name="landscape_mode_desc" msgid="7372569859592816793">"スマートフォンを横表示にしてください"</string>
+    <string name="landscape_mode_desc" msgid="7372569859592816793">"スマートフォンを横表示にします"</string>
     <string name="notification_dots_title" msgid="9062440428204120317">"通知ドット"</string>
     <string name="notification_dots_desc_on" msgid="1679848116452218908">"ON"</string>
     <string name="notification_dots_desc_off" msgid="1760796511504341095">"OFF"</string>
@@ -184,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"ショートカット メニュー"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"表示しない"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"閉じる"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"個人用"</string>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"仕事用"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"個人用アプリのタブ"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"仕事用アプリのタブ"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"仕事用プロファイル"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"仕事用アプリはバッジ付きで表示され、IT 管理者に公開されます"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"OK"</string>
@@ -216,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"プライベート スペース移行中"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"インストール"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"プライベート スペースにアプリをインストールします"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-ka/strings.xml b/res/values-ka/strings.xml
index 2fd6b77..108176b 100644
--- a/res/values-ka/strings.xml
+++ b/res/values-ka/strings.xml
@@ -131,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"ფონი და სტილი"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"მთავარი ეკრანის რედაქტირება"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"მთავარი გვერდის პარამეტრები"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"გათიშულია თქვენი ადმინისტრატორის მიერ"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"მთავარი ეკრანის შეტრიალების დაშვება"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"ტელეფონის შეტრიალებისას"</string>
@@ -184,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"მალსახმობის მენიუ"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"დახურვა"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"დახურვა"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"პირადი"</string>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"სამსახური"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"პირადი აპების ჩანართი"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"სამსახურის აპების ჩანართი"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"სამსახურის პროფილი"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"სამსახურის აპები ბეჯით არის მონიშნული და ხილულია თქვენი IT ადმინისტრატორისთვის"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"გასაგებია"</string>
@@ -216,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"პირად სივრცეზე გადასვლა"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"ინსტალაცია"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"კერძო სივრცეში აპების ინსტალაცია"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-kk/strings.xml b/res/values-kk/strings.xml
index fee3a9a..c789a8f 100644
--- a/res/values-kk/strings.xml
+++ b/res/values-kk/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"%1$d бет, барлығы %2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"%1$d негізгі экран, барлығы %2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"Жаңа негізгі экран беті"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"Белсенді"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"Кішірейтілген"</string>
     <string name="folder_opened" msgid="94695026776264709">"Қалта ашылды, <xliff:g id="WIDTH">%1$d</xliff:g> және <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"Қалтаны жабу үшін түртіңіз"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"Қайта атауды сақтау үшін түртіңіз"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Тұсқағаз және стиль"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Негізгі экранды өзгерту"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Негізгі экран параметрлері"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Әкімші өшірді"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Негізгі экранды бұруға рұқсат ету"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Телефон бұрылғанда"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Жылдам пәрмен мәзірі"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Бас тарту"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Жабу"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Жеке"</string>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Жұмыс"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Жеке қолданбалар қойындысы"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Жұмыс қолданбалары қойындысы"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Жұмыс профилі"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Жұмыс қолданбаларының танымбелгілері бар және олар әкімшіңізге көрінеді."</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"Түсінікті"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Жеке бөлмеге өту"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Орнату"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Қолданбаларды \"Құпия кеңістікке\" орнатыңыз."</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-km/strings.xml b/res/values-km/strings.xml
index cc8539e..1c12f04 100644
--- a/res/values-km/strings.xml
+++ b/res/values-km/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"ទំព័រ %1$d នៃ %2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"អេក្រង់​ដើម %1$d នៃ %2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"ទំព័រអេក្រង់ដើមថ្មី"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"សកម្ម"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"បានបង្រួម"</string>
     <string name="folder_opened" msgid="94695026776264709">"បាន​បើក​ថត <xliff:g id="WIDTH">%1$d</xliff:g> ដោយ <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"ប៉ះ ដើម្បីបិទថត"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"ប៉ះដើម្បីរក្សាទុកឈ្មោះដែលបានប្តូរ"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"ផ្ទាំងរូបភាព និងរចនាបថ"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"កែអេក្រង់ដើម"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"ការកំណត់​ទំព័រដើម"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"បានបិទដំណើរការដោយអ្នកគ្រប់គ្រងរបស់អ្នក"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"អនុញ្ញាតការបងិ្វលអេក្រង់ដើម"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"នៅពេលដែលបង្វិលទូរសព្ទ"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"ម៉ឺនុយផ្លូវ​កាត់"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"ច្រានចោល"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"បិទ"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"ផ្ទាល់ខ្លួន"</string>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"ការងារ"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"ផ្ទាំងកម្មវិធី​ផ្ទាល់ខ្លួន"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"ផ្ទាំងកម្មវិធី​ការងារ"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"កម្រងព័ត៌មានការងារ"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"កម្មវិធីការងារ​ត្រូវបានដាក់​គ្រឿងសម្គាល់ ហើយ​អ្នកគ្រប់គ្រង​ផ្នែកព័ត៌មានវិទ្យា​របស់អ្នក​អាចមើលឃើញ"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"យល់ហើយ"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"ការផ្លាស់ប្ដូរ Private Space"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"ដំឡើង"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"ដំឡើងកម្មវិធីទៅលំហឯកជន"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-kn/strings.xml b/res/values-kn/strings.xml
index cd5d59d..e30b80b 100644
--- a/res/values-kn/strings.xml
+++ b/res/values-kn/strings.xml
@@ -131,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"ವಾಲ್‌ಪೇಪರ್ ಮತ್ತು ಶೈಲಿ"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"ಹೋಮ್ ಸ್ಕ್ರೀನ್ ಅನ್ನು ಎಡಿಟ್ ಮಾಡಿ"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"ಹೋಮ್ ಸೆಟ್ಟಿಂಗ್‌ಗಳು"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"ನಿಮ್ಮ ನಿರ್ವಾಹಕರು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಿದ್ದಾರೆ"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"ಹೋಮ್ ಸ್ಕ್ರೀನ್ ತಿರುಗುವಿಕೆಯನ್ನು ಅನುಮತಿಸಿ"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"ಫೋನ್‌ ತಿರುಗಿಸಿದಾಗ"</string>
@@ -184,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"ಶಾರ್ಟ್‌ಕಟ್ ಮೆನು"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"ವಜಾಗೊಳಿಸಿ"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"ಮುಚ್ಚಿರಿ"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"ವೈಯಕ್ತಿಕ"</string>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"ಕೆಲಸ"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"ವೈಯಕ್ತಿಕ ಆ್ಯಪ್‌ಗಳ ಟ್ಯಾಬ್"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"ಕೆಲಸಕ್ಕೆ ಸಂಬಂಧಿಸಿದ ಆ್ಯಪ್‌ಗಳ ಟ್ಯಾಬ್"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"ಕೆಲಸದ ಪ್ರೊಫೈಲ್"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"ಕೆಲಸಕ್ಕೆ ಸಂಬಂಧಿಸಿದ ಆ್ಯಪ್‌ಗಳನ್ನು ಬ್ಯಾಡ್ಜ್ ಮಾಡಲಾಗಿದೆ ಮತ್ತು ಅವುಗಳು ನಿಮ್ಮ IT ನಿರ್ವಾಹಕರಿಗೆ ಗೋಚರಿಸುತ್ತವೆ"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"ಸರಿ"</string>
@@ -216,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"ಖಾಸಗಿ ಸ್ಪೇಸ್ ಪರಿವರ್ತನೆಯಾಗುತ್ತಿದೆ"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"ಇನ್‌ಸ್ಟಾಲ್"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"ಆ್ಯಪ್‌ಗಳನ್ನು ಪ್ರೈವೇಟ್ ಸ್ಪೇಸ್‌ನಲ್ಲಿ ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡಿ"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-ko/strings.xml b/res/values-ko/strings.xml
index e588634..1d60d88 100644
--- a/res/values-ko/strings.xml
+++ b/res/values-ko/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"페이지 %1$d/%2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"홈 화면 %1$d/%2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"새로운 홈 화면 페이지"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"활성"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"최소화"</string>
     <string name="folder_opened" msgid="94695026776264709">"폴더 열림(<xliff:g id="WIDTH">%1$d</xliff:g>X<xliff:g id="HEIGHT">%2$d</xliff:g>)"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"탭하여 폴더 닫기"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"탭하여 변경된 이름 저장"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"배경화면 및 스타일"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"홈 화면 수정"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"홈 설정"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"관리자가 사용 중지함"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"홈 화면 회전 허용"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"휴대전화 회전 시"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"바로가기 메뉴"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"닫기"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"닫기"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"개인"</string>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"직장"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"개인 앱 탭"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"직장 앱 탭"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"직장 프로필"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"직장 앱에는 배지가 있으며, IT 관리자는 직장 앱을 확인할 수 있습니다"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"확인"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"비공개 스페이스 전환"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"설치"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"비공개 스페이스에 앱 설치"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-ky/strings.xml b/res/values-ky/strings.xml
index fb1675e..638e107 100644
--- a/res/values-ky/strings.xml
+++ b/res/values-ky/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"%2$d ичинен %1$d барак"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"Үй экраны %2$d ичинен %1$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"Жаңы башкы экран барагы"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"Жигердүү"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"Кичирейтилди"</string>
     <string name="folder_opened" msgid="94695026776264709">"Фолдер ачылды, туурасы <xliff:g id="WIDTH">%1$d</xliff:g>, бийиктиги <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"Куржунду жабуу үчүн таптаңыз"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"Өзгөртүлгөн аталышын сактоо үчүн таптаңыз"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Тушкагаз жана стиль"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Башкы экранды түзөтүү"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Башкы бет параметрлери"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Администраторуңуз өчүрүп койгон"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Башкы экранды бурууга уруксат берүү"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Телефон бурулганда"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Ыкчам баскычтын менюсу"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Этибарга албоо"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Жабуу"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Жеке колдонмолор"</string>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Жумуш колдонмолору"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Жеке колдонмолор өтмөгү"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Жумуш колдонмолор өтмөгү"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Жумуш профили"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Жумуш колдонмолору белгиленип, аларды IT администраторлору көрөт"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"Түшүндүм"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Жеке чөйрөгө өтүү"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Орнотуу"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Колдонмолорду Жеке мейкиндикке орнотуe"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-lo/strings.xml b/res/values-lo/strings.xml
index 2aaf40b..d459fd9 100644
--- a/res/values-lo/strings.xml
+++ b/res/values-lo/strings.xml
@@ -131,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"ຮູບພື້ນຫຼັງ ແລະ ຮູບແບບ"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"ແກ້ໄຂໂຮມສະກຣີນ"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"ການຕັ້ງຄ່າໜ້າຫຼັກ"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"ຖືກປິດການນຳໃຊ້ໂດຍຜູ້ເບິ່ງແຍງລະບົບຂອງທ່ານ"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"ອະນຸຍາດໃຫ້ໝຸນໜ້າຈໍຢູ່ໂຮມສະກຣີນໄດ້"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"ເມື່ອໝຸນໂທລະສັບ"</string>
@@ -184,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"ເມນູທາງລັດ"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"ປິດໄວ້"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"ປິດ"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"ສ່ວນຕົວ"</string>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"ວຽກ"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"ແຖບແອັບສ່ວນຕົວ"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"ແຖບແອັບບ່ອນເຮັດວຽກ"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"ໂປຣໄຟລ໌ບ່ອນເຮັດວຽກ"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"ແອັບບ່ອນເຮັດວຽກແມ່ນຖືກຕິດປ້າຍ ແລະ ສະແດງໃຫ້ຜູ້ເບິ່ງແຍງໄອທີຂອງທ່ານເຫັນ"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"ເຂົ້າໃຈແລ້ວ"</string>
@@ -216,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"ການປ່ຽນແປງພື້ນທີ່ສ່ວນຕົວ"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"ຕິດຕັ້ງ"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"ຕິດຕັ້ງແອັບໄປໃສ່ພື້ນທີ່ສ່ວນບຸກຄົນ"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-lt/strings.xml b/res/values-lt/strings.xml
index aeba444..2421ddd 100644
--- a/res/values-lt/strings.xml
+++ b/res/values-lt/strings.xml
@@ -131,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Ekrano fonas ir stilius"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Redaguoti pagrindinį ekraną"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Pagrindinio ekrano nustatymai"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Išjungė administratorius"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Leisti pasukti pagrindinį ekraną"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Kai telefonas pasukamas"</string>
@@ -184,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Sparčiųjų klavišų meniu"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Darbo"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Asmeninių programų skirtukas"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Darbo programų skirtukas"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Darbo profilis"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Darbo programos yra pažymėtos ženkleliu ir matomos IT administratoriui"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"Supratau"</string>
@@ -216,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Privačios erdvės perkėlimas"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Įdiegti"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Įdiegti programas privačioje erdvėje"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-lv/strings.xml b/res/values-lv/strings.xml
index 0ba127d..fa4dd27 100644
--- a/res/values-lv/strings.xml
+++ b/res/values-lv/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"%1$d. lapa no %2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"Sākuma ekrāns: %1$d no %2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"Jauna sākuma ekrāna lapa"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"Aktīva"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"Minimizēta"</string>
     <string name="folder_opened" msgid="94695026776264709">"Atvērta mape: <xliff:g id="WIDTH">%1$d</xliff:g> x <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"Pieskarieties, lai aizvērtu mapi."</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"Pieskarieties, lai saglabātu jauno nosaukumu."</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Fona tapete un stils"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Rediģēt sākuma ekrānu"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Sākumlapas iestatījumi"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Atspējojis administrators"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Atļaut sākuma ekrāna pagriešanu"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Pagriežot tālruni"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Saīsnes izvēlne"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Darba lietotnes"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Cilne Personīgās lietotnes"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Cilne Darba lietotnes"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Darba profils"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Darba lietotnēm ir pievienota emblēma, un tās ir redzamas jūsu IT administratoram"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"Labi"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Pāriet uz privāto mapi"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Instalēt"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Instalējiet lietotnes privātajā telpā."</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-mk/strings.xml b/res/values-mk/strings.xml
index ba119f7..aebd1f1 100644
--- a/res/values-mk/strings.xml
+++ b/res/values-mk/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"Страница %1$d од %2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"Екран на почетна страница %1$d од %2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"Нова страница на почетен екран"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"Активно"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"Минимизирано"</string>
     <string name="folder_opened" msgid="94695026776264709">"Отворена е папка, <xliff:g id="WIDTH">%1$d</xliff:g> на <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"Допрете за да ја затворите папката"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"Допрете за да го зачувате преименувањето"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Тапет и стил"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Изменете го почетниот екран"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Поставки за почетен екран"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Оневозможено од администраторот"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Дозволи ротирање на почетниот екран"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Кога телефонот се ротира"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Мени за кратенки"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Отфрли"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Затвори"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Лично"</string>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"За работа"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Картичка „Лични апликации“"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Картичка „Работни апликации“"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Работен профил"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Работните апликации имаат значка и се видливи за IT-администраторот"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"Сфатив"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Префрлање на „Приватен простор“"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Инсталирајте"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Инсталирање апликации во „Приватен простор“"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-ml/strings.xml b/res/values-ml/strings.xml
index 2a2e050..68d484b 100644
--- a/res/values-ml/strings.xml
+++ b/res/values-ml/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"പേജ് %1$d / %2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"ഹോം സ്‌ക്രീൻ %1$d / %2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"പുതിയ ഹോം സ്ക്രീൻ പേജ്"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"സജീവം"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"ചെറുതാക്കി"</string>
     <string name="folder_opened" msgid="94695026776264709">"ഫോൾഡർ തുറന്നു, <xliff:g id="WIDTH">%1$d</xliff:g> / <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"ഫോൾഡർ അടയ്ക്കുന്നതിന് ടാപ്പുചെയ്യുക"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"പേരുമാറ്റം സംരക്ഷിക്കുന്നതിന് ടാപ്പുചെയ്യുക"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"വാൾപേപ്പറും സ്‌റ്റൈലും"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"ഹോം സ്‌ക്രീൻ എഡിറ്റ് ചെയ്യുക"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"ഹോം ക്രമീകരണം"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"അഡ്മിൻ പ്രവർത്തനരഹിതമാക്കിയിരിക്കുന്നു"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"ഹോം സ്ക്രീൻ റൊട്ടേഷൻ അനുവദിക്കുക"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"ഫോൺ തിരിച്ച നിലയിലായിരിക്കുമ്പോൾ"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"കുറുക്കുവഴി മെനു"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"നിരസിക്കുക"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"അടയ്ക്കൂ"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"വ്യക്തിപരം"</string>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Work"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"വ്യക്തിപര ആപ്പുകളുടെ ടാബ്"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"ഔദ്യോഗിക ആപ്പുകളുടെ ടാബ്"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"ഔദ്യോഗിക പ്രൊഫൈൽ"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"ഔദ്യോഗിക ആപ്പുകൾക്ക് ബാഡ്‌ജ് നൽകിയിരിക്കുന്നു, അവ നിങ്ങളുടെ ഐടി അഡ്‌മിന് കാണാനുമാകും"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"മനസ്സിലായി"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"പ്രൈവറ്റ് സ്‌പേസ് ട്രാൻസിഷനിംഗ്"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"ഇൻസ്റ്റാൾ ചെയ്യുക"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"സ്വകാര്യ സ്പേസിലേക്ക് ആപ്പുകൾ ഇൻസ്റ്റാൾ ചെയ്യുക"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-mn/strings.xml b/res/values-mn/strings.xml
index ffe1b2c..1eeea10 100644
--- a/res/values-mn/strings.xml
+++ b/res/values-mn/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"%2$d-н %1$d хуудас"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"%2$d-н Нүүр дэлгэц %1$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"Шинэ үндсэн нүүр хуудас"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"Идэвхтэй"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"Жижгэрүүлсэн"</string>
     <string name="folder_opened" msgid="94695026776264709">"<xliff:g id="WIDTH">%1$d</xliff:g> <xliff:g id="HEIGHT">%2$d</xliff:g> фолдер нээгдэв"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"Фолдерийг хаахын тулд дарна уу"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"Шинэ нэрийг хадгалахын тулд дарна уу."</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Дэлгэцийн зураг, загвар"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Үндсэн нүүрийг засах"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Нүүр хуудасны тохиргоо"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Таны админ идэвхгүй болгосон"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Үндсэн нүүрийг эргүүлэхийг зөвшөөрөх"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Утсыг эргүүлсэн үед"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Товчлолын цэс"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Хаах"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Хаах"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Хувийн"</string>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Ажил"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Хувийн апп таб"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Ажлын апп таб"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Ажлын профайл"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Ажлын аппуудыг тэмдэглэсэн бөгөөд танай IT админд харагдана"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"Ойлголоо"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Private Space-н шилжилт"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Суулгах"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Хувийн орон зайд аппууд суулгана уу"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-mr/strings.xml b/res/values-mr/strings.xml
index b249150..5c19b74 100644
--- a/res/values-mr/strings.xml
+++ b/res/values-mr/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"%2$d पैकी %1$d पेज"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"%2$d पैकी %1$d मुख्य स्क्रीन"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"नवीन होम स्क्रीन पेज"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"अ‍ॅक्टिव्ह"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"लहान केलेले"</string>
     <string name="folder_opened" msgid="94695026776264709">"फोल्डर उघडले, <xliff:g id="WIDTH">%1$d</xliff:g> बाय <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"फोल्डर बंद करण्यासाठी टॅप करा"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"पुनर्नामित करणे सेव्ह करण्यासाठी टॅप करा"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"वॉलपेपर आणि शैली"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"होम स्क्रीन संपादित करा"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"होम सेटिंग्‍ज"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"आपल्या प्रशासकाने अक्षम केले"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"होम स्क्रीन फिरवण्‍याची अनुमती द्या"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"फोन फिरवला जातो तेव्हा"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"शॉर्टकट मेनू"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"डिसमिस करा"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"बंद करा"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"वैयक्तिक"</string>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"कार्य"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"वैयक्तिक ॲप्स टॅब"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Work apps टॅब"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"कार्य प्रोफाइल"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"कार्य ॲप्स ही बॅज केलेली असून तुमच्या आयटी ॲडमिनला दृश्यमान आहेत"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"समजले"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"खाजगी स्पेस वर स्विच करणे"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"इंस्टॉल करा"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"अ‍ॅप्स खाजगी स्पेस मध्ये इंस्टॉल करा"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-ms/strings.xml b/res/values-ms/strings.xml
index 3585ec7..4982d02 100644
--- a/res/values-ms/strings.xml
+++ b/res/values-ms/strings.xml
@@ -131,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Hiasan latar &amp; gaya"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Edit Skrin Utama"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Tetapan skrin utama"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Dilumpuhkan oleh pentadbir anda"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Benarkan putaran skrin utama"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Apabila telefon diputar"</string>
@@ -184,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Menu Pintasan"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Kerja"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Tab apl peribadi"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Tab apl kerja"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Profil kerja"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Apl kerja mempunyai lencana dan kelihatan kepada pentadbir IT anda"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"OK"</string>
@@ -216,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Peralihan Ruang Peribadi"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Pasang"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Pasang apl pada Ruang Peribadi"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-my/strings.xml b/res/values-my/strings.xml
index 0116834..9ef1758 100644
--- a/res/values-my/strings.xml
+++ b/res/values-my/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"စာမျက်နှာ %1$d မှ %2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"ပင်မစာမျက်နှာ %1$d မှ %2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"ပင်မမျက်နှာပြင် စာမျက်နှာသစ်"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"သုံးနေသည်"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"ချုံ့ထားသည်"</string>
     <string name="folder_opened" msgid="94695026776264709">"ဖွင့်ထားသောအကန့်, <xliff:g id="WIDTH">%1$d</xliff:g> နှင့် <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"ဖိုင်တွဲကို ပိတ်ရန် တို့ပါ"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"အမည်ပြောင်းခြင်းကို သိမ်းရန် တို့ပါ"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"နောက်ခံနှင့် ပုံစံ"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"ပင်မစာမျက်နှာ တည်းဖြတ်ရန်"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"ပင်မဆက်တင်များ"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"သင့်စီမံခန့်ခွဲသူက ပိတ်လိုက်ပါသည်"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"ပင်မစာမျက်နှာလှည့်ခြင်းကို ခွင့်ပြုခြင်း"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"ဖုန်းကိုလှည့်ထားစဉ်"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"ဖြတ်လမ်းလင့်ခ် မီနူး"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"ပယ်ရန်"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"ပိတ်ရန်"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"ကိုယ်ပိုင်"</string>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"အလုပ်"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"ကိုယ်ရေးသုံးအက်ပ် တဘ်"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"အလုပ်သုံးအက်ပ် တဘ်"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"အလုပ်ပရိုဖိုင်"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"အလုပ်သုံးအက်ပ်များကို တံဆိပ်တပ်ထားပြီး သင်၏ IT စီမံခန့်ခွဲသူက မြင်နိုင်ပါသည်"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"ရပါပြီ"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"သီးသန့်ချတ်ခန်း အပြောင်းအလဲ"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"ထည့်သွင်းရန်"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"‘သီးသန့်နေရာ’ တွင် အက်ပ်များ ထည့်သွင်းနိုင်သည်"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-nb/strings.xml b/res/values-nb/strings.xml
index 47c6abb..4fb3642 100644
--- a/res/values-nb/strings.xml
+++ b/res/values-nb/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"Side %1$d av %2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"Startside %1$d av %2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"Ny side på startskjermen"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"Aktiv"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"Minimert"</string>
     <string name="folder_opened" msgid="94695026776264709">"Mappen er åpnet – <xliff:g id="WIDTH">%1$d</xliff:g> ganger <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"Trykk for å lukke mappen"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"Trykk for å lagre det nye navnet"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Bakgrunn og stil"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Endre startsiden"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Startsideinnstillinger"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Administratoren har slått av funksjonen"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Tillat at startskjermen roterer"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Når telefonen roteres"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Hurtigtastmeny"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Jobb"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Personlige apper-fane"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Jobbapper-fane"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Jobbprofil"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Jobbapper er merket og synlige for IT-administratoren"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"Greit"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Private Space-overgang"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Installer"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Installer apper i privat område"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-ne/strings.xml b/res/values-ne/strings.xml
index e451926..38167de 100644
--- a/res/values-ne/strings.xml
+++ b/res/values-ne/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"पृष्ठ %2$d को %1$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"होम स्क्रिन %1$d को %2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"नयाँ होम स्क्रिन पृष्ठ"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"सक्रिय"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"सानो पारिएको"</string>
     <string name="folder_opened" msgid="94695026776264709">"फोल्डर खुल्यो <xliff:g id="WIDTH">%1$d</xliff:g> बाट <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"फोल्डरलाई बन्द गर्न ट्याप गर्नुहोस्"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"पुनःनामाकरणलाई सुरक्षित गर्न ट्याप गर्नुहोस्"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"वालपेपर तथा शैली"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"होम स्क्रिन बदल्नुहोस्"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"होम पेजका सेटिङहरू"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"तपाईँको प्रशासकद्वारा असक्षम गरिएको"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"होम स्क्रिन रोटेट हुन दिइयोस्"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"फोन घुमाउँदा"</string>
@@ -186,6 +186,10 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"सर्टकटसम्बन्धी मेनु"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"खारेज गर्नुहोस्"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"बन्द गर्नुहोस्"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"व्यक्तिगत"</string>
@@ -218,4 +222,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"निजी स्पेस ट्रान्जिसन गरिँदै छ"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"इन्स्टल गर्नुहोस्"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"निजी स्पेसमा एपहरू इन्स्टल गर्नुहोस्"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-nl/strings.xml b/res/values-nl/strings.xml
index 75793b0..2b99b69 100644
--- a/res/values-nl/strings.xml
+++ b/res/values-nl/strings.xml
@@ -131,11 +131,13 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Achtergrond en stijl"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Startscherm bewerken"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Instellingen Start"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Uitgezet door je beheerder"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Draaien van startscherm toestaan"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Als de telefoon gedraaid is"</string>
     <string name="landscape_mode_title" msgid="5138814555934843926">"Liggende modus"</string>
-    <string name="landscape_mode_desc" msgid="7372569859592816793">"Telefoon instellen op liggende modus"</string>
+    <string name="landscape_mode_desc" msgid="7372569859592816793">"Stel telefoon in op liggende modus"</string>
     <string name="notification_dots_title" msgid="9062440428204120317">"Meldingsstipjes"</string>
     <string name="notification_dots_desc_on" msgid="1679848116452218908">"Aan"</string>
     <string name="notification_dots_desc_off" msgid="1760796511504341095">"Uit"</string>
@@ -184,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Snelmenu"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Werk"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Tabblad Persoonlijke apps"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Tabblad Werk-apps"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Werkprofiel"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Werk-apps hebben badges en zijn zichtbaar voor je IT-beheerder"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"OK"</string>
@@ -216,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Overschakelen naar privéruimte"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Installeren"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Apps installeren in privégedeelte"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-or/strings.xml b/res/values-or/strings.xml
index 98ccaf1..2b924de 100644
--- a/res/values-or/strings.xml
+++ b/res/values-or/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"ମୋଟ %2$dରୁ %1$d ନମ୍ବର ପୃଷ୍ଠା"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"%2$dରୁ %1$d ହୋମ ସ୍କ୍ରିନ"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"ନୂଆ ହୋମ ସ୍କ୍ରିନ ପେଜ"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"ସକ୍ରିୟ"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"ଛୋଟ କରାଯାଇଛି"</string>
     <string name="folder_opened" msgid="94695026776264709">"<xliff:g id="HEIGHT">%2$d</xliff:g> / <xliff:g id="WIDTH">%1$d</xliff:g>ର ଫୋଲ୍ଡର ଖୋଲାଗଲା"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"ଫୋଲ୍ଡର୍‌ ବନ୍ଦ କରିବାକୁ ଟାପ୍‌ କରନ୍ତୁ"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"ନାମ ବଦଳାଇବା ସେଭ୍ କରିବାକୁ ଟାପ୍‌ କରନ୍ତୁ"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"ୱାଲପେପର ଏବଂ ଷ୍ଟାଇଲ"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"ହୋମ ସ୍କ୍ରିନକୁ ଏଡିଟ କରନ୍ତୁ"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"ହୋମ ସେଟିଂସ"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"ଆପଣଙ୍କ ଆଡମିନଙ୍କ ଦ୍ୱାରା ଅକ୍ଷମ କରାଯାଇଛି"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"ହୋମ ସ୍କ୍ରିନ ରୋଟେସନକୁ ଅନୁମତି ଦିଅନ୍ତୁ"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"ଯେତେବେଳେ ଫୋନକୁ ରୋଟେଟ କରାଯାଇଥାଏ"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"ସର୍ଟକଟ ମେନୁ"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"ଖାରଜ କରନ୍ତୁ"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"ବନ୍ଦ କରନ୍ତୁ"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"ବ୍ୟକ୍ତିଗତ"</string>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"ୱାର୍କ"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"ବ୍ୟକ୍ତିଗତ ଆପ୍ସ ଟାବ"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"ୱାର୍କ ଆପ୍ସ ଟାବ"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"ୱର୍କ ପ୍ରୋଫାଇଲ୍‌"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"ୱାର୍କ ଆପ୍ସକୁ ବେଜ କରାଯାଇଛି ଏବଂ ସେଗୁଡ଼ିକ ଆପଣଙ୍କ IT ଆଡମିନଙ୍କୁ ଦେଖାଯାଉଛି"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"ବୁଝିଗଲି"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"ପ୍ରାଇଭେଟ ସ୍ପେସ ଟ୍ରାଞ୍ଜିସନିଂ"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"ଇନଷ୍ଟଲ କରନ୍ତୁ"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"ଆପ୍ସକୁ ପ୍ରାଇଭେଟ ସ୍ପେସରେ ଇନଷ୍ଟଲ କରନ୍ତୁ"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-pa/strings.xml b/res/values-pa/strings.xml
index 3904473..934266d 100644
--- a/res/values-pa/strings.xml
+++ b/res/values-pa/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"ਸਫ਼ਾ %2$d ਦਾ %1$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"ਹੋਮ ਸਕ੍ਰੀਨ %2$d ਦੀ %1$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"ਨਵਾਂ ਹੋਮ ਸਕ੍ਰੀਨ ਸਫ਼ਾ"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"ਕਿਰਿਆਸ਼ੀਲ"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"ਛੋਟਾ ਕੀਤਾ ਗਿਆ"</string>
     <string name="folder_opened" msgid="94695026776264709">"ਫੋਲਡਰ ਖੋਲ੍ਹਿਆ, <xliff:g id="WIDTH">%1$d</xliff:g> ਬਾਇ <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"ਫੋਲਡਰ ਬੰਦ ਕਰਨ ਲਈ ਟੈਪ ਕਰੋ"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"ਬਦਲੇ ਗਏ ਨਾਮ ਨੂੰ ਰੱਖਿਅਤ ਕਰਨ ਲਈ ਟੈਪ ਕਰੋ"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"ਵਾਲਪੇਪਰ ਅਤੇ ਸਟਾਈਲ"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"ਹੋਮ ਸਕ੍ਰੀਨ ਦਾ ਸੰਪਾਦਨ ਕਰੋ"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"ਹੋਮ ਸੈਟਿੰਗਾਂ"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"ਤੁਹਾਡੇ ਪ੍ਰਸ਼ਾਸਕ ਦੁਆਰਾ ਅਯੋਗ ਬਣਾਈ ਗਈ"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"ਹੋਮ ਸਕ੍ਰੀਨ ਨੂੰ ਘੁਮਾਉਣ ਦੀ ਆਗਿਆ ਦਿਓ"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"ਜਦੋਂ ਫ਼ੋਨ ਘੁਮਾਇਆ ਜਾਂਦਾ ਹੈ"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"ਸ਼ਾਰਟਕੱਟ ਮੀਨੂ"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"ਖਾਰਜ ਕਰੋ"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"ਬੰਦ ਕਰੋ"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"ਨਿੱਜੀ"</string>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"ਕੰਮ ਸੰਬੰਧੀ"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"ਨਿੱਜੀ ਐਪਾਂ ਟੈਬ"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"ਕੰਮ ਸੰਬੰਧੀ ਐਪਾਂ ਟੈਬ"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"ਕਾਰਜ ਪ੍ਰੋਫਾਈਲ"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"ਕੰਮ ਸੰਬੰਧੀ ਐਪਾਂ ਨੂੰ ਬੈਜ ਕੀਤਾ ਗਿਆ ਹੈ ਅਤੇ ਇਹ ਤੁਹਾਡੇ ਆਈ.ਟੀ. ਪ੍ਰਸ਼ਾਸਕ ਨੂੰ ਦਿਸਣਗੀਆਂ"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"ਸਮਝ ਲਿਆ"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"ਪ੍ਰਾਈਵੇਟ ਸਪੇਸ ਨੂੰ ਤਬਦੀਲ ਕਰਨਾ"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"ਸਥਾਪਤ ਕਰੋ"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"ਪ੍ਰਾਈਵੇਟ ਸਪੇਸ ਵਿੱਚ ਐਪਾਂ ਸਥਾਪਤ ਕਰੋ"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-pl/strings.xml b/res/values-pl/strings.xml
index f7f71f4..36fa4e8 100644
--- a/res/values-pl/strings.xml
+++ b/res/values-pl/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"Strona %1$d z %2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"Ekran główny %1$d z %2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"Nowa strona ekranu głównego"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"Aktywna"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"Zminimalizowana"</string>
     <string name="folder_opened" msgid="94695026776264709">"Folder otwarty, <xliff:g id="WIDTH">%1$d</xliff:g> na <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"Kliknij, by zamknąć folder"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"Kliknij, by zapisać nową nazwę"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Tapeta i styl"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Edytuj ekran główny"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Ustawienia ekranu głównego"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Funkcja wyłączona przez administratora"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Zezwalaj na obrót ekranu głównego"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Po obróceniu telefonu"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Menu skrótów"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Służbowe"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Karta aplikacji osobistych"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Karta aplikacji służbowych"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Profil służbowy"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Aplikacje służbowe mają plakietki i są widoczne dla administratora IT"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"OK"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Przenoszenie obszaru prywatnego"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Zainstaluj"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Zainstaluj aplikacje w przestrzeni prywatnej"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-pt-rPT/strings.xml b/res/values-pt-rPT/strings.xml
index 24235d1..50252d5 100644
--- a/res/values-pt-rPT/strings.xml
+++ b/res/values-pt-rPT/strings.xml
@@ -131,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Imagem fundo/estilo"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Editar ecrã principal"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Definições de início"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Desativada pelo gestor"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Permitir rotação do ecrã principal"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Quando o telemóvel é rodado"</string>
@@ -184,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Menu de atalho"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Trabalho"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Separador de apps pessoais"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Separador de apps de trabalho"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Perfil de trabalho"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"As apps de trabalho têm um emblema e estão visíveis para o seu administrador de TI"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"OK"</string>
@@ -216,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Transição do espaço privado"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Instalar"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Instale apps no espaço privado"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-pt/strings.xml b/res/values-pt/strings.xml
index d0e1178..9c7261b 100644
--- a/res/values-pt/strings.xml
+++ b/res/values-pt/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"Página %1$d de %2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"Tela inicial %1$d de %2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"Nova página na tela inicial"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"Ativo"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"Minimizado"</string>
     <string name="folder_opened" msgid="94695026776264709">"Pasta aberta, <xliff:g id="WIDTH">%1$d</xliff:g> por <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"Toque para fechar a pasta"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"Toque para salvar o novo nome"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Plano de fundo e estilo"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Editar tela inicial"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Configurações da tela inicial"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Desativado pelo administrador"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Permitir a rotação da tela inicial"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Quando o smartphone for girado"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Menu de atalhos"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Trabalho"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Guia de apps pessoais"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Guia de apps de trabalho"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Perfil de trabalho"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Os apps de trabalho são identificados e ficam visíveis para o adm. de TI"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"Ok"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Espaço particular em transição"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Instalar"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Instalar apps no espaço privado"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-ro/strings.xml b/res/values-ro/strings.xml
index 9022d6f..458f46e 100644
--- a/res/values-ro/strings.xml
+++ b/res/values-ro/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"Pagina %1$d din %2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"Ecranul de pornire %1$d din %2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"Pagină nouă pe ecranul de pornire"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"Activă"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"Minimizată"</string>
     <string name="folder_opened" msgid="94695026776264709">"Dosar deschis, <xliff:g id="WIDTH">%1$d</xliff:g> pe <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"Atinge pentru a închide dosarul"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"Atinge pentru a salva noul nume"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Imagine de fundal și stil"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Editează ecranul de pornire"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Setări ecran de pornire"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Dezactivată de administrator"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Permite rotirea ecranului de pornire"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Când telefonul este rotit"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Meniu de comenzi rapide"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Profesionale"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Fila Aplicații personale"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Fila Aplicații pentru lucru"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Profil de serviciu"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Aplicațiile pentru lucru sunt marcate și vizibile pentru administratorul IT"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"OK"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Tranziție pentru spațiul privat"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Instalează"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Instalează aplicații în Spațiul privat"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-ru/strings.xml b/res/values-ru/strings.xml
index a0230e2..5299596 100644
--- a/res/values-ru/strings.xml
+++ b/res/values-ru/strings.xml
@@ -131,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Обои и стиль"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Изменить главный экран"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Главный экран"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Функция отключена администратором"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Разрешить поворачивать главный экран"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"При повороте телефона"</string>
@@ -184,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Быстрое меню"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Закрыть"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Закрыть"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Личные"</string>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Рабочие"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Вкладка \"Личные приложения\""</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Вкладка \"Рабочие приложения\""</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Рабочий профиль"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"У рабочих приложений есть специальный значок. Они видны системному администратору."</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"ОК"</string>
@@ -216,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Переход к личному пространству"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Установить"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Установить приложения в личном пространстве"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-si/strings.xml b/res/values-si/strings.xml
index 7e64c0d..766dafd 100644
--- a/res/values-si/strings.xml
+++ b/res/values-si/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"%2$d හි %1$d පිටුව"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"මුල් පිටු තිරය %2$d හි %1$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"නව මුල් පිටුව"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"සක්‍රිය"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"කුඩා කරන ලදි"</string>
     <string name="folder_opened" msgid="94695026776264709">"ෆෝල්ඩරය විවෘත විය, <xliff:g id="WIDTH">%1$d</xliff:g> හි <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"ෆෝල්ඩරය වැසීමට තට්ටු කරන්න"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"යළි නම් කිරීම සුරැකීමට තට්ටු කරන්න"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"වෝල්පේපරය සහ මෝස්තරය"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"මුල් තිරය සංස්කරණය කරන්න"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"නිවසේ සැකසීම්"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"ඔබගේ පරිපාලක විසින් අබල කරන ලදී"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"මුල් තිරය කරකැවීමට ඉඩ දෙන්න"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"දුරකථනය කරකවන විට"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"කෙටිමං මෙනුව"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"ඉවතලන්න"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"වසන්න"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"පුද්ගලික"</string>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"කාර්යාලය"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"පුද්ගලික යෙදුම් පටිත්ත"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"කාර්ය යෙදුම් ටැබය"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"කාර්යාල පැතිකඩ"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"කාර්යාල යෙදුම්වලට ලාංඡන යොදා ඇති අතර ඔබගේ IT පරිපාලකට දෘශ්‍යමාන වේ"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"තේරුණා"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"පෞද්ගලික අවකාශ සංක්‍රමණය"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"ස්ථාපන කරන්න"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"පෞද්ගලික අවකාශයට යෙදුම් ස්ථාපනය කරන්න"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-sk/strings.xml b/res/values-sk/strings.xml
index ba174ad..465ed09 100644
--- a/res/values-sk/strings.xml
+++ b/res/values-sk/strings.xml
@@ -131,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Tapeta a štýl"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Upraviť plochu"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Nastavenia plochy"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Zakázané vaším správcom"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Povoliť otáčanie plochy"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Pri otočení telefónu"</string>
@@ -184,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Ponuka skratiek"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Pracovné"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Karta Osobné aplikácie"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Karta Pracovné aplikácie"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Pracovný profil"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Pracovné aplikácie majú odznak a zobrazujú sa správcovi IT"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"Dobre"</string>
@@ -216,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Prechod súkromného priestoru"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Inštalovať"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Inštalácia aplikácií v súkromnom priestore"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-sl/strings.xml b/res/values-sl/strings.xml
index 9fabdcf..a32a0a9 100644
--- a/res/values-sl/strings.xml
+++ b/res/values-sl/strings.xml
@@ -131,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Zaslonsko ozadje in slog"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Urejanje začetnega zaslona"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Začetni zaslon"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Onemogočil skrbnik."</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Dovoli sukanje začetnega zaslona"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Ko se telefon zasuka"</string>
@@ -184,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Meni z bližnjicami"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Delo"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Zavihek z osebnimi aplikacijami"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Zavihek z delovnimi aplikacijami"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Delovni profil"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Delovne aplikacije so označene z značko in vidne skrbniku za IT."</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"Razumem"</string>
@@ -216,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Preklapljanje zasebnega prostora"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Namestitev"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Nameščanje aplikacij v zasebni prostor"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-sq/strings.xml b/res/values-sq/strings.xml
index ac47b0a..d1b955c 100644
--- a/res/values-sq/strings.xml
+++ b/res/values-sq/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"Faqja: %1$d nga gjithsej %2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"Ekrani bazë: %1$d nga gjithsej %2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"Faqja e ekranit të ri kryesor"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"Aktiv"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"Minimizuar"</string>
     <string name="folder_opened" msgid="94695026776264709">"Dosja u hap, <xliff:g id="WIDTH">%1$d</xliff:g> me <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"Trokit për të mbyllur dosjen"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"Trokit për të ruajtur riemërtimin"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Imazhi i sfondit dhe stili"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Modifiko ekranin bazë"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Cilësimet e ekranit bazë"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Çaktivizuar nga administratori"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Lejo rrotullimin e ekranit bazë"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Kur telefoni rrotullohet"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Menyja e shkurtoreve"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Punë"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Skeda e aplikacioneve personale"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Skeda e aplikacioneve të punës"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Profili i punës"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Aplikacionet e punës janë të shënuara dhe të dukshme për administratorin e teknologjisë së informacionit"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"E kuptova"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Kalimi te \"Hapësira private\""</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Instalo"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Instalo aplikacionet në hapësirën private"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-sr/strings.xml b/res/values-sr/strings.xml
index fea7de5..ca04201 100644
--- a/res/values-sr/strings.xml
+++ b/res/values-sr/strings.xml
@@ -131,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Позадина и стил"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Измени почетни екран"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Подешавања почетног екрана"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Администратор је онемогућио"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Дозволи ротацију почетног екрана"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Када се телефон ротира"</string>
@@ -184,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Мени са пречицама"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Одбаци"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Затвори"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Лично"</string>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Посао"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Картица Личне апликације"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Картица Пословне апликације"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Пословни профил"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Пословне апликације су означене значком и ИТ администратор може да их види"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"Важи"</string>
@@ -216,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Пренос приватног простора"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Инсталирајте"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Инсталирај апликације у приватан простор"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-sv/strings.xml b/res/values-sv/strings.xml
index 7c676e9..dd91e4b 100644
--- a/res/values-sv/strings.xml
+++ b/res/values-sv/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"Sidan %1$d av %2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"Startskärmen %1$d av %2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"Ny sida på startskärmen"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"Aktivt"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"Minimerat"</string>
     <string name="folder_opened" msgid="94695026776264709">"Mappen är öppen, <xliff:g id="WIDTH">%1$d</xliff:g> gånger <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"Tryck för att stänga mappen"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"Tryck för att spara namnändringen"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Bakgrund och utseende"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Redigera startskärm"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Startinställningar"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Inaktiverat av administratören"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Tillåt rotering av startskärmen"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"När telefonen vrids"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Snabbmeny"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Arbete"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Fliken Privata appar"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Fliken Jobbappar"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Jobbprofil"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Jobbappar är märkta och synliga för IT-administratören"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"OK"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Överföring av privat rum"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Installera"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Installera appar i privat rum"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-sw/strings.xml b/res/values-sw/strings.xml
index 06ba981..bd6e135 100644
--- a/res/values-sw/strings.xml
+++ b/res/values-sw/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"Ukurasa%1$d wa %2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"Skrini ya mwanzo %1$d ya %2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"Ukurasa mpya wa skrini ya kwanza"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"Inatumika"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"Imepunguzwa"</string>
     <string name="folder_opened" msgid="94695026776264709">"Folda imefunguliwa, <xliff:g id="WIDTH">%1$d</xliff:g> kwa <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"Gusa ili ufunge folda"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"Gusa ili ubadilishe jina"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Mandhari na mtindo"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Badilisha Skrini ya Kwanza"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Mipangilio ya mwanzo"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Imezimwa na msimamizi wako"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Ruhusu kipengele cha kuzungusha skrini ya kwanza"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Simu inapozungushwa"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Menyu ya Njia za Mkato"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Kazini"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Kichupo cha programu za binafsi"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Kichupo cha programu za kazini"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Wasifu wa kazini"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Programu za kazini zina beji na msimamizi wako wa TEHAMA anaziona"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"Nimeelewa"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Mabadiliko ya Nafasi ya Faragha"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Weka"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Sakinisha programu kwenye Sehemu ya Faragha"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-sw600dp/styles.xml b/res/values-sw600dp/styles.xml
index 63bd46b..db49a3e 100644
--- a/res/values-sw600dp/styles.xml
+++ b/res/values-sw600dp/styles.xml
@@ -14,8 +14,11 @@
   ~ limitations under the License.
   -->
 
-<resources>
+<resources xmlns:android="http://schemas.android.com/apk/res/android">
     <style name="CellStyleDefault">
         <item name="iconDrawablePadding">7dp</item>
     </style>
+    <style name="DropTargetButton" parent="DropTargetButtonBase">
+        <item name="android:fontFamily" android:featureFlag="com.android.launcher3.gsf_res">variable-title-large</item>
+    </style>
 </resources>
\ No newline at end of file
diff --git a/res/values-ta/strings.xml b/res/values-ta/strings.xml
index 4bb86da..743df88 100644
--- a/res/values-ta/strings.xml
+++ b/res/values-ta/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"பக்கம் %1$d / %2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"முகப்புத் திரை %1$d of %2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"புதிய முகப்புத் திரை பக்கம்"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"செயலில் உள்ளது"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"சிறிதாக்கப்பட்டது"</string>
     <string name="folder_opened" msgid="94695026776264709">"திறக்கப்பட்ட ஃபோல்டர், <xliff:g id="WIDTH">%1$d</xliff:g> x <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"ஃபோல்டரை மூட, தட்டவும்"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"மாற்றிய பெயரைச் சேமிக்க, தட்டவும்"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"வால்பேப்பர் &amp; ஸ்டைல்"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"முகப்புத் திரையில் மாற்று"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"முகப்பு அமைப்புகள்"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"உங்கள் நிர்வாகி முடக்கியுள்ளார்"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"முகப்புத் திரை சுழற்சியை அனுமதித்தல்"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"மொபைலைச் சுழற்றும் போது"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"ஷார்ட்கட் மெனு"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"நிராகரி"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"மூடும் பட்டன்"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"தனிப்பட்டவை"</string>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"பணி"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"தனிப்பட்ட ஆப்ஸ் பிரிவு"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"பணி ஆப்ஸ் பிரிவு"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"பணிக் கணக்கு"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"பணி ஆப்ஸில் பேட்ஜ் இடப்பட்டிருக்கும், உங்கள் IT நிர்வாகியால் பணி ஆப்ஸைப் பார்க்க முடியும்"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"முடிந்தது"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"தனிப்பட்ட சேமிப்பிடத்திற்கு மாற்றுகிறது"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"நிறுவுக"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"தனிப்பட்ட சேமிப்பிடத்தில் ஆப்ஸை நிறுவும்"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-te/strings.xml b/res/values-te/strings.xml
index cd4f456..4df936c 100644
--- a/res/values-te/strings.xml
+++ b/res/values-te/strings.xml
@@ -131,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"వాల్‌పేపర్ &amp; స్టయిల్"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"మొదటి స్క్రీన్‌ను ఎడిట్ చేయండి"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"మొదటి స్క్రీన్ సెట్టింగ్‌లు"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"మీ నిర్వాహకులు నిలిపివేసారు"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"మొదటి స్క్రీన్ రొటేషన్‌ను అనుమతించండి"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"ఫోన్‌‌ను తిప్పినప్పుడు"</string>
@@ -184,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"షార్ట్‌కట్ మెనూ"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"తీసివేయండి"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"మూసివేస్తుంది"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"వ్యక్తిగతం"</string>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"వర్క్"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"వ్యక్తిగత యాప్‌ల ట్యాబ్"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"వర్క్ యాప్‌ల ట్యాబ్"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"కార్యాలయ ప్రొఫైల్"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"వర్క్ యాప్‌లకు బ్యాడ్జ్ ఉంటుంది, అవి మీ IT అడ్మిన్‌కు కనిపిస్తాయి"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"అర్థమైంది"</string>
@@ -216,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"ప్రైవేట్ స్పేస్ కేటాయించడం జరుగుతుంది"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"ఇన్‌స్టాల్ చేయండి"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"ప్రైవేట్ స్పేస్‌కు యాప్‌లను ఇన్‌స్టాల్ చేయండి"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-th/strings.xml b/res/values-th/strings.xml
index 1aa4a97..9107582 100644
--- a/res/values-th/strings.xml
+++ b/res/values-th/strings.xml
@@ -131,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"วอลเปเปอร์และสไตล์"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"แก้ไขหน้าจอหลัก"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"การตั้งค่าหน้าจอหลัก"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"ปิดใช้โดยผู้ดูแลระบบ"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"อนุญาตให้หมุนหน้าจอหลัก"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"เมื่อหมุนโทรศัพท์"</string>
@@ -184,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"เมนูแป้นพิมพ์ลัด"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"ปิด"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"ปิด"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"ส่วนตัว"</string>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"งาน"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"แท็บแอปส่วนตัว"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"แท็บแอปงาน"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"โปรไฟล์งาน"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"แอปงานจะติดป้ายไว้และผู้ดูแลระบบไอทีจะมองเห็น"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"รับทราบ"</string>
@@ -216,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"การเปลี่ยนไปใช้พื้นที่ส่วนตัว"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"ติดตั้ง"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"ติดตั้งแอปไปยังพื้นที่ส่วนตัว"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-tl/strings.xml b/res/values-tl/strings.xml
index b8a0df4..59661c0 100644
--- a/res/values-tl/strings.xml
+++ b/res/values-tl/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"Pahina %1$d ng %2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"Home screen %1$d ng %2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"Bagong page ng home screen"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"Aktibo"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"Na-minimize"</string>
     <string name="folder_opened" msgid="94695026776264709">"Binuksan ang folder, <xliff:g id="WIDTH">%1$d</xliff:g> by <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"I-tap upang isara ang folder"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"I-tap upang i-save ang bagong pangalan"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Wallpaper &amp; istilo"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"I-edit ang Home Screen"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Mga setting ng Home"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Na-disable ng iyong admin"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Payagan ang pag-rotate ng home screen"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Kailan maro-rotate ang telepono"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Menu ng Shortcut"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Trabaho"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Tab ng mga personal na app"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Tab ng mga app para sa trabaho"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Profile sa trabaho"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"May badge at nakikita ng iyong IT admin ang mga app para sa trabaho"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"OK"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Pag-transition ng Pribadong Space"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"I-install"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Mag-install ng mga app sa Pribadong Space"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-tr/strings.xml b/res/values-tr/strings.xml
index 5bd7c52..c834f6c 100644
--- a/res/values-tr/strings.xml
+++ b/res/values-tr/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"Sayfa %1$d / %2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"Ana ekran %1$d / %2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"Yeni ana ekran sayfası"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"Etkin"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"Simge durumuna küçültülmüş"</string>
     <string name="folder_opened" msgid="94695026776264709">"Klasör açıldı, <xliff:g id="WIDTH">%1$d</xliff:g> x <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"Klasörü kapatmak için dokunun"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"Yeni adın kaydedilmesi için dokunun"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Duvar kağıdı ve stil"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Ana ekranı düzenleyin"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Ana ekran ayarları"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Yöneticiniz tarafından devre dışı bırakıldı"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Ana ekranı döndürmeye izin ver"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Telefon döndürüldüğünde"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Kısayol Menüsü"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"İş"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Kişisel uygulamalar sekmesi"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"İş uygulamaları sekmesi"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"İş profili"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"İş uygulamaları rozetle işaretlenmiş olup BT yöneticisi tarafından görülebilir"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"Anladım"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Gizli Alana Geçiş"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Yükle"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Uygulamaları özel alana yükleyin"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-uk/strings.xml b/res/values-uk/strings.xml
index 798c567..318944f 100644
--- a/res/values-uk/strings.xml
+++ b/res/values-uk/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"Сторінка %1$d з %2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"Головний екран %1$d з %2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"Нова сторінка головного екрана"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"Додаток активний"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"Додаток згорнуто"</string>
     <string name="folder_opened" msgid="94695026776264709">"Папку відкрито (<xliff:g id="WIDTH">%1$d</xliff:g> х <xliff:g id="HEIGHT">%2$d</xliff:g>)"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"Торкніться, щоб закрити папку"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"Торкніться, щоб зберегти зміни"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Оформлення й стиль"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Редагувати головний екран"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Налаштування головного екрана"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Вимкнув адміністратор"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Дозволити обертання головного екрана"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Коли телефон обертається"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Меню швидкого доступу"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"Закрити"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"Закрити"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Особисті додатки"</string>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Робочі додатки"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Вкладка особистих додатків"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Вкладка робочих додатків"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Робочий профіль"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Робочі додатки мають спеціальну позначку. Їх бачить системний адміністратор."</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"OK"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Перехід у приватний простір"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Установити"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Установити додатки в особистому просторі"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-ur/strings.xml b/res/values-ur/strings.xml
index ec5129d..efe5297 100644
--- a/res/values-ur/strings.xml
+++ b/res/values-ur/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"‏صفحہ ‎%1$d از ‎%2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"‏ہوم اسکرین ‎%1$d از ‎%2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"نیا ہوم اسکرین صفحہ"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"فعال"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"کم کر دیا گیا"</string>
     <string name="folder_opened" msgid="94695026776264709">"فولڈر کھولا گیا، <xliff:g id="WIDTH">%1$d</xliff:g> × <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"فولڈر کو بند کرنے کیلئے تھپتھپائیں"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"نام کی تبدیلی محفوظ کرنے کیلئے تھپتھپائیں"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"وال پیپر اور طرز"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"ہوم اسکرین میں ترمیم کریں"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"ہوم ترتیبات"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"آپ کے منتظم کی طرف سے غیر فعال کر دیا گیا"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"ہوم اسکرین گھمانے کی اجازت دیں"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"جب فون گھمایا جاتا ہے"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"شارٹ کٹ مینیو"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"برخاست کریں"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"بند کریں"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"ذاتی"</string>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"دفتری"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"ذاتی ایپس کا ٹیب"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"ورک ایپس کا ٹیب"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"دفتری پروفائل"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"‏ورک ایپس پر بَیج لگا ہوتا ہے اور آپ کا IT منتظم انہیں دیکھ سکتا ہے"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"سمجھ آ گئی"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"نجی اسپیس کی منتقلی"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"انسٹال کریں"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"پرائیویٹ اسپیس میں ایپس انسٹال کریں"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-uz/strings.xml b/res/values-uz/strings.xml
index 48068d6..8d65f8c 100644
--- a/res/values-uz/strings.xml
+++ b/res/values-uz/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"%2$ddan %1$d ta sahifa"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"Uy ekrani %2$ddan %1$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"Yangi bosh ekran sahifasi"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"Faol"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"Yigʻilgan"</string>
     <string name="folder_opened" msgid="94695026776264709">"Jild ochildi, <xliff:g id="WIDTH">%1$d</xliff:g> ga <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"Jildni yopish uchun ustiga bosing"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"O‘zgarishni saqlash uchun ustiga bosing"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Fon rasmi va uslubi"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Bosh ekranni tahrirlash"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Bosh ekran sozlamalari"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Administrator tomonidan o‘chirilgan"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Bosh ekranni burishga ruxsat"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Telefon burilganda"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Tezkor tugma menyusi"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Ish"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Shaxsiy ilovalar sahifasi"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Ishga oid ilovalar sahifasi"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Ish profili"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Ishga oid ilovalarning maxsus belgisi bor hamda ular administratoringizga koʻrinadi"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"OK"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Maxfiy joyga almashtirish"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Oʻrnatish"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Ilovalarni Maxfiy makonga oʻrnatish"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-v31/styles.xml b/res/values-v31/styles.xml
index 932ce38..6ed7dd6 100644
--- a/res/values-v31/styles.xml
+++ b/res/values-v31/styles.xml
@@ -17,7 +17,7 @@
 */
 -->
 
-<resources>
+<resources xmlns:android="http://schemas.android.com/apk/res/android">
 
     <style name="HomeSettings.Theme" parent="@android:style/Theme.DeviceDefault.Settings">
         <item name="android:listPreferredItemPaddingEnd">16dp</item>
@@ -29,6 +29,7 @@
         <item name="android:windowActionBar">false</item>
         <item name="android:windowNoTitle">true</item>
         <item name="preferenceTheme">@style/HomeSettings.PreferenceTheme</item>
+        <item name="android:fontFamily" android:featureFlag="com.android.launcher3.gsf_res">google-sans-flex</item>
     </style>
 
     <style name="HomeSettings.PreferenceTheme" parent="@style/PreferenceThemeOverlay">
@@ -80,11 +81,13 @@
 
     <style name="HomeSettings.CollapsedToolbarTitle"
             parent="@android:style/TextAppearance.DeviceDefault.Widget.ActionBar.Title">
-        <item name="android:fontFamily">google-sans</item>
+        <item name="android:fontFamily" android:featureFlag="!com.android.launcher3.gsf_res">google-sans</item>
+        <item name="android:fontFamily" android:featureFlag="com.android.launcher3.gsf_res">variable-title-large</item>
         <item name="android:textSize">20sp</item>
     </style>
 
     <style name="HomeSettings.ExpandedToolbarTitle" parent="HomeSettings.CollapsedToolbarTitle">
+        <item name="android:fontFamily" android:featureFlag="com.android.launcher3.gsf_res">variable-display-small</item>
         <item name="android:textSize">36sp</item>
     </style>
 </resources>
\ No newline at end of file
diff --git a/res/values-vi/strings.xml b/res/values-vi/strings.xml
index 5b88099..78cf3e3 100644
--- a/res/values-vi/strings.xml
+++ b/res/values-vi/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"Trang %1$d / %2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"Màn hình chính %1$d / %2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"Trang màn hình chính mới"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"Đang hoạt động"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"Đã thu nhỏ"</string>
     <string name="folder_opened" msgid="94695026776264709">"Đã mở thư mục, <xliff:g id="WIDTH">%1$d</xliff:g> x <xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"Nhấn để đóng thư mục"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"Nhấn để lưu đổi tên"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Hình nền và phong cách"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Chỉnh sửa Màn hình chính"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Cài đặt màn hình chính"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Bị tắt bởi quản trị viên của bạn"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Cho phép xoay màn hình chính"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Khi xoay điện thoại"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Trình đơn lối tắt"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Công việc"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Thẻ ứng dụng cá nhân"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Thẻ ứng dụng công việc"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Hồ sơ công việc"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Các ứng dụng công việc được gắn huy hiệu và quản trị viên CNTT có thể nhìn thấy"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"OK"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Chuyển đổi sang không gian riêng tư"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Cài đặt"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Cài đặt ứng dụng vào Không gian riêng tư"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-zh-rCN/strings.xml b/res/values-zh-rCN/strings.xml
index 7b51d1d..6e69045 100644
--- a/res/values-zh-rCN/strings.xml
+++ b/res/values-zh-rCN/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"第%1$d页，共%2$d页"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"主屏幕：第%1$d屏，共%2$d屏"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"主屏幕新页面"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"活跃"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"已最小化"</string>
     <string name="folder_opened" msgid="94695026776264709">"文件夹已打开，大小为<xliff:g id="WIDTH">%1$d</xliff:g>×<xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"点按可关闭文件夹"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"点按可保存新名称"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"壁纸与风格"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"修改主屏幕"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"主屏幕设置"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"已被您的管理员停用"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"允许旋转主屏幕"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"手机旋转时"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"快捷键菜单"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"关闭"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"关闭"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"个人"</string>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"工作"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"“个人应用”标签页"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"“工作应用”标签页"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"工作资料"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"工作应用都有相应的标志，且您的 IT 管理员可以看到它们"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"知道了"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"私密空间转换"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"安装"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"将应用安装到私密空间"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-zh-rHK/strings.xml b/res/values-zh-rHK/strings.xml
index 0dd1801..2e0e929 100644
--- a/res/values-zh-rHK/strings.xml
+++ b/res/values-zh-rHK/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"第 %1$d 頁，共 %2$d 頁"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"主畫面 %1$d，共 %2$d 個"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"新主畫面頁面"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"運作中"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"已縮到最小"</string>
     <string name="folder_opened" msgid="94695026776264709">"資料夾已開啟 (<xliff:g id="WIDTH">%1$d</xliff:g> x <xliff:g id="HEIGHT">%2$d</xliff:g>)"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"輕按即可關閉資料夾"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"輕按即可儲存新名稱"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"桌布和樣式"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"編輯主畫面"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"主畫面設定"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"已由你的管理員停用"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"允許旋轉主畫面"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"隨手機旋轉"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"快速鍵選單"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"關閉"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"關閉"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"個人"</string>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"工作"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"個人應用程式分頁"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"工作應用程式分頁"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"工作設定檔"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"工作應用程式均加有標誌。你的 IT 管理員可以看到這些應用程式"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"知道了"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"轉為「私人空間」"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"安裝"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"將應用程式安裝在「私人空間」中"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-zh-rTW/strings.xml b/res/values-zh-rTW/strings.xml
index 424939b..2b4a8b3 100644
--- a/res/values-zh-rTW/strings.xml
+++ b/res/values-zh-rTW/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"第 %1$d 頁，共 %2$d 頁"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"主畫面：第 %1$d 頁，共 %2$d 頁"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"新的主畫面頁面"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"運作中"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"最小化"</string>
     <string name="folder_opened" msgid="94695026776264709">"資料夾已開啟 (<xliff:g id="WIDTH">%1$d</xliff:g> x <xliff:g id="HEIGHT">%2$d</xliff:g>)"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"輕觸即可關閉資料夾"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"輕觸即可儲存新名稱"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"桌布和樣式"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"編輯主畫面"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"主畫面設定"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"已由你的管理員停用"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"允許旋轉主畫面"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"當手機旋轉時"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"快速鍵選單"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <string name="action_dismiss_notification" msgid="5909461085055959187">"關閉"</string>
     <string name="accessibility_close" msgid="2277148124685870734">"關閉"</string>
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"個人"</string>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"工作"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"個人應用程式分頁"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"工作應用程式分頁"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"工作資料夾"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"工作應用程式會加上標記，且你的 IT 管理員可以看到這類應用程式"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"我知道了"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"轉換私人空間狀態"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"安裝"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"將應用程式安裝在私人空間中"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values-zu/strings.xml b/res/values-zu/strings.xml
index 918b7ca..dc40b80 100644
--- a/res/values-zu/strings.xml
+++ b/res/values-zu/strings.xml
@@ -117,10 +117,8 @@
     <string name="default_scroll_format" msgid="7475544710230993317">"Ikhasi elingu-%1$d kwangu-%2$d"</string>
     <string name="workspace_scroll_format" msgid="8458889198184077399">"Isikrini sasekhaya esingu-%1$d se-%2$d"</string>
     <string name="workspace_new_page" msgid="257366611030256142">"Ikhasi elisha lesikrini sasekhaya"</string>
-    <!-- no translation found for app_running_state_description (5645053189564740904) -->
-    <skip />
-    <!-- no translation found for app_minimized_state_description (710740620044902509) -->
-    <skip />
+    <string name="app_running_state_description" msgid="5645053189564740904">"Kuyasebenza"</string>
+    <string name="app_minimized_state_description" msgid="710740620044902509">"Kuncishisiwe"</string>
     <string name="folder_opened" msgid="94695026776264709">"Ifolda ivuliwe, <xliff:g id="WIDTH">%1$d</xliff:g> nge-<xliff:g id="HEIGHT">%2$d</xliff:g>"</string>
     <string name="folder_tap_to_close" msgid="4625795376335528256">"Thepa ukuze uvale ifolda"</string>
     <string name="folder_tap_to_rename" msgid="4017685068016979677">"Thepha ukuze ulondoloze ukuqamba kabusha"</string>
@@ -133,6 +131,8 @@
     <string name="styles_wallpaper_button_text" msgid="8216961355289236794">"Isithombe sangemuva nesitayela"</string>
     <string name="edit_home_screen" msgid="8947858375782098427">"Hlela Isikrini Sasekhaya"</string>
     <string name="settings_button_text" msgid="8873672322605444408">"Amasethingi asekhaya"</string>
+    <!-- no translation found for all_apps_home_screen (8658178652647896497) -->
+    <skip />
     <string name="msg_disabled_by_admin" msgid="6898038085516271325">"Kukhutshazwe umlawuli wakho"</string>
     <string name="allow_rotation_title" msgid="7222049633713050106">"Vumela ukuzungezisa kwesikrini sasekhaya"</string>
     <string name="allow_rotation_desc" msgid="8662546029078692509">"Uma ifoni iphendukiswa"</string>
@@ -186,14 +186,16 @@
     <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>
     <string name="action_deep_shortcut" msgid="4766835855579976045">"Imenyu Yezinqamuleli"</string>
+    <!-- no translation found for widget_frame_name (8782828448471444270) -->
+    <skip />
+    <!-- no translation found for action_close (1077760267194136901) -->
+    <skip />
     <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>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Umsebenzi"</string>
-    <!-- no translation found for all_apps_personal_tab_content_description (6286808898381807242) -->
-    <skip />
-    <!-- no translation found for all_apps_work_tab_content_description (3835637212347968316) -->
-    <skip />
+    <string name="all_apps_personal_tab_content_description" msgid="6286808898381807242">"Ithebhu yama-app omuntu siqu"</string>
+    <string name="all_apps_work_tab_content_description" msgid="3835637212347968316">"Ithebhu yama-app omsebenzi"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Iphrofayela yomsebenzi"</string>
     <string name="work_profile_edu_work_apps" msgid="7895468576497746520">"Ama-app omsebenzi anebheji futhi ayabonakala kumphathi wakho we-IT"</string>
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"Ngiyezwa"</string>
@@ -218,4 +220,6 @@
     <string name="ps_container_transition" msgid="8667331812048014412">"Ukuguqulwa Kwendawo Yangasese"</string>
     <string name="ps_add_button_label" msgid="8127988716897128773">"Faka"</string>
     <string name="ps_add_button_content_description" msgid="3254274107740952556">"Faka ama-app Endaweni Engasese"</string>
+    <!-- no translation found for ps_app_content_description (1129133475892816226) -->
+    <skip />
 </resources>
diff --git a/res/values/attrs.xml b/res/values/attrs.xml
index a22f943..1ecac33 100644
--- a/res/values/attrs.xml
+++ b/res/values/attrs.xml
@@ -19,6 +19,7 @@
 
     <!-- Attributes used for launcher theme -->
     <attr name="allAppsScrimColor" format="color" />
+    <attr name="allAppsScrimColorOverBlur" format="color" />
     <attr name="allappsHeaderProtectionColor" format="color" />
     <attr name="allAppsNavBarScrimColor" format="color" />
     <attr name="allAppsTheme" format="reference" />
diff --git a/res/values/config.xml b/res/values/config.xml
index d65580c..fc636a5 100644
--- a/res/values/config.xml
+++ b/res/values/config.xml
@@ -68,7 +68,6 @@
     <string name="app_launch_tracker_class" translatable="false"></string>
     <string name="test_information_handler_class" translatable="false"></string>
     <string name="secondary_display_predictions_class" translatable="false"></string>
-    <string name="widget_holder_factory_class" translatable="false"></string>
     <string name="taskbar_search_session_controller_class" translatable="false"></string>
     <string name="taskbar_model_callbacks_factory_class" translatable="false"></string>
     <string name="taskbar_view_callbacks_factory_class" translatable="false"></string>
@@ -224,4 +223,7 @@
          of the same name in SystemUI. -->
     <string-array name="config_appsSupportMultiInstancesSplit">
     </string-array>
+
+    <!-- Used to differentiate between desktop and non-desktop devices. -->
+    <bool name="desktop_form_factor">false</bool>
 </resources>
diff --git a/res/values/strings.xml b/res/values/strings.xml
index cc740a5..a626097 100644
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -323,6 +323,8 @@
     <string name="edit_home_screen">Edit Home Screen</string>
     <!-- Text for settings button [CHAR LIMIT=20]-->
     <string name="settings_button_text">Home settings</string>
+    <!-- Text for app menu button [CHAR LIMIT=30]-->
+    <string name="all_apps_home_screen">Apps</string>
     <!-- Message shown when a feature is disabled by the administrator -->
     <string name="msg_disabled_by_admin">Disabled by your admin</string>
 
@@ -469,6 +471,12 @@
     <!-- Accessibility action to show quick actions menu for an icon. [CHAR_LIMIT=30] -->
     <string name="action_deep_shortcut">Shortcut Menu</string>
 
+    <!-- Accessibility name for the app widget resize frame. -->
+    <string name="widget_frame_name">Widget Resize Frame for <xliff:g id="string" example="Clock">%1$s</xliff:g></string>
+
+    <!-- Accessibility action to close the widget resize frame. [CHAR_LIMIT=30] -->
+    <string name="action_close">Close</string>
+
     <!-- Accessibility action to dismiss a notification in the shortcuts menu for an icon. [CHAR_LIMIT=30] -->
     <string name="action_dismiss_notification">Dismiss</string>
 
@@ -541,4 +549,5 @@
     <string name="ps_add_button_label">Install</string>
     <!-- Content description for install app icon -->
     <string name="ps_add_button_content_description">Install apps to Private Space</string>
+    <string name="ps_app_content_description">Add files and more to Private Space</string>
 </resources>
diff --git a/res/values/styles.xml b/res/values/styles.xml
index 04421c0..cf6c560 100644
--- a/res/values/styles.xml
+++ b/res/values/styles.xml
@@ -40,6 +40,7 @@
     <style name="LauncherTheme" parent="@style/DynamicColorsBaseLauncherTheme">
         <item name="android:textColorSecondary">#DE000000</item>
         <item name="allAppsScrimColor">@color/materialColorSurfaceDim</item>
+        <item name="allAppsScrimColorOverBlur">#33000000</item>
         <item name="allappsHeaderProtectionColor">@color/materialColorSurfaceContainerHighest</item>
         <item name="allAppsNavBarScrimColor">#66FFFFFF</item>
         <item name="popupColorPrimary">@color/popup_color_primary_light</item>
@@ -114,6 +115,7 @@
         <item name="android:colorControlHighlight">#19FFFFFF</item>
         <item name="android:colorPrimary">#FF212121</item>
         <item name="allAppsScrimColor">@color/materialColorSurfaceDim</item>
+        <item name="allAppsScrimColorOverBlur">#52000000</item>
         <item name="allappsHeaderProtectionColor">@color/materialColorSurfaceContainerLow</item>
         <item name="allAppsNavBarScrimColor">#80000000</item>
         <item name="popupColorPrimary">@color/popup_color_primary_dark</item>
@@ -371,7 +373,9 @@
         <item name="android:background">@drawable/drop_target_background</item>
     </style>
 
-    <style name="DropTargetButton" parent="DropTargetButtonBase" />
+    <style name="DropTargetButton" parent="DropTargetButtonBase">
+        <item name="android:fontFamily" android:featureFlag="com.android.launcher3.gsf_res">variable-title-medium</item>
+    </style>
 
     <style name="TextHeadline" parent="@android:style/TextAppearance.DeviceDefault.DialogWindowTitle" />
 
diff --git a/src/com/android/launcher3/AppWidgetResizeFrame.java b/src/com/android/launcher3/AppWidgetResizeFrame.java
index b51e850..213d88f 100644
--- a/src/com/android/launcher3/AppWidgetResizeFrame.java
+++ b/src/com/android/launcher3/AppWidgetResizeFrame.java
@@ -216,6 +216,13 @@
         AppWidgetResizeFrame frame = (AppWidgetResizeFrame) launcher.getLayoutInflater()
                 .inflate(R.layout.app_widget_resize_frame, dl, false);
         frame.setupForWidget(widget, cellLayout, dl);
+        // Save widget item info as tag on resize frame; so that, the accessibility delegate can
+        // attach actions that typically happen on widget (e.g. resize, move) also on the resize
+        // frame.
+        frame.setTag(widget.getTag());
+        frame.setAccessibilityDelegate(launcher.getAccessibilityDelegate());
+        frame.setContentDescription(launcher.asContext().getString(R.string.widget_frame_name,
+                widget.getContentDescription()));
         ((DragLayer.LayoutParams) frame.getLayoutParams()).customPosition = true;
 
         dl.addView(frame);
@@ -235,6 +242,13 @@
         }
     }
 
+    /**
+     *  Retrieves the view where accessibility actions happen.
+     */
+    public View getViewForAccessibility() {
+        return mWidgetView;
+    }
+
     private void setupForWidget(LauncherAppWidgetHostView widgetView, CellLayout cellLayout,
             DragLayer dragLayer) {
         mCellLayout = cellLayout;
diff --git a/src/com/android/launcher3/BubbleTextView.java b/src/com/android/launcher3/BubbleTextView.java
index 783e82c..30e3a2b 100644
--- a/src/com/android/launcher3/BubbleTextView.java
+++ b/src/com/android/launcher3/BubbleTextView.java
@@ -26,6 +26,7 @@
 import static com.android.launcher3.BubbleTextView.RunningAppState.MINIMIZED;
 import static com.android.launcher3.Flags.enableContrastTiles;
 import static com.android.launcher3.Flags.enableCursorHoverStates;
+import static com.android.launcher3.allapps.AlphabeticalAppsList.PRIVATE_SPACE_PACKAGE;
 import static com.android.launcher3.graphics.PreloadIconDrawable.newPendingIcon;
 import static com.android.launcher3.icons.BitmapInfo.FLAG_NO_BADGE;
 import static com.android.launcher3.icons.BitmapInfo.FLAG_SKIP_USER_BADGE;
@@ -104,6 +105,7 @@
 import java.text.NumberFormat;
 import java.util.HashMap;
 import java.util.Locale;
+import java.util.Objects;
 
 /**
  * TextView that draws a bubble behind the text. We cannot use a LineBackgroundSpan
@@ -589,7 +591,9 @@
     }
 
     private void setNonPendingIcon(ItemInfoWithIcon info) {
-        int flags = shouldUseTheme() ? FLAG_THEMED : info.bitmap.creationFlags;
+        // Set nonPendingIcon acts as a restart which should refresh the flag state when applicable.
+        int flags = Objects.equals(info.getTargetPackage(), PRIVATE_SPACE_PACKAGE)
+                ? info.bitmap.creationFlags : shouldUseTheme() ? FLAG_THEMED : 0;
         // Remove badge on icons smaller than 48dp.
         if (mHideBadge || mDisplay == DISPLAY_SEARCH_RESULT_SMALL) {
             flags |= FLAG_NO_BADGE;
diff --git a/src/com/android/launcher3/DeviceProfile.java b/src/com/android/launcher3/DeviceProfile.java
index c85ca49..090208a 100644
--- a/src/com/android/launcher3/DeviceProfile.java
+++ b/src/com/android/launcher3/DeviceProfile.java
@@ -30,8 +30,8 @@
 import static com.android.launcher3.testing.shared.ResourceUtils.pxFromDp;
 import static com.android.launcher3.testing.shared.ResourceUtils.roundPxValueFromFloat;
 import static com.android.wm.shell.Flags.enableBubbleBar;
-import static com.android.wm.shell.Flags.enableTinyTaskbar;
 import static com.android.wm.shell.Flags.enableBubbleBarOnPhones;
+import static com.android.wm.shell.Flags.enableTinyTaskbar;
 
 import android.annotation.SuppressLint;
 import android.content.Context;
@@ -508,9 +508,11 @@
 
         bottomSheetOpenDuration = res.getInteger(R.integer.config_bottomSheetOpenDuration);
         bottomSheetCloseDuration = res.getInteger(R.integer.config_bottomSheetCloseDuration);
-        if (isTablet) {
+        if (shouldShowAllAppsOnSheet()) {
             bottomSheetWorkspaceScale = workspaceContentScale;
-            if (isMultiDisplay) {
+            if (Flags.allAppsBlur()) {
+                bottomSheetDepth = 2f;
+            } else if (isMultiDisplay) {
                 // TODO(b/259893832): Revert to use maxWallpaperScale to calculate bottomSheetDepth
                 // when screen recorder bug is fixed.
                 if (enableScalingRevealHomeAnimation()) {
@@ -1830,10 +1832,17 @@
                         workspacePageIndicatorHeight - mWorkspacePageIndicatorOverlapWorkspace;
             }
             int paddingTop = workspaceTopPadding + (mIsScalableGrid ? 0 : edgeMarginPx);
-            // On isFixedLandscapeMode on phones we already have padding because of the camera hole
-            int paddingSide = inv.isFixedLandscape ? 0 : desiredWorkspaceHorizontalMarginPx;
+            int paddingLeft = desiredWorkspaceHorizontalMarginPx;
+            int paddingRight = desiredWorkspaceHorizontalMarginPx;
 
-            padding.set(paddingSide, paddingTop, paddingSide, paddingBottom);
+            // In fixed Landscape we don't need padding on the side next to the cutout because
+            // the cutout is already adding padding to all of Launcher, we only need on the other
+            // side
+            if (inv.isFixedLandscape) {
+                paddingLeft = isSeascape() ? desiredWorkspaceHorizontalMarginPx : 0;
+                paddingRight = isSeascape() ? 0 : desiredWorkspaceHorizontalMarginPx;
+            }
+            padding.set(paddingLeft, paddingTop, paddingRight, paddingBottom);
         }
         insetPadding(workspacePadding, cellLayoutPaddingPx);
     }
@@ -1931,7 +1940,24 @@
                 hotseatBarPadding.set(mHotseatBarWorkspaceSpacePx, paddingTop,
                         mInsets.right + mHotseatBarEdgePaddingPx, paddingBottom);
             }
-        } else if (isTaskbarPresent || inv.isFixedLandscape) {
+        } else if (inv.isFixedLandscape) {
+            // Center the QSB vertically with hotseat
+            int hotseatBarBottomPadding = getHotseatBarBottomPadding();
+            int hotseatPlusQSBWidth = getHotseatRequiredWidth();
+            int qsbWidth = getAdditionalQsbSpace();
+            int availableWidthPxForHotseat = availableWidthPx - Math.abs(workspacePadding.width())
+                    - Math.abs(cellLayoutPaddingPx.width());
+            int remainingSpaceOnSide = (availableWidthPxForHotseat - hotseatPlusQSBWidth) / 2;
+
+            hotseatBarPadding.set(
+                    (remainingSpaceOnSide + qsbWidth) + mInsets.left + workspacePadding.left
+                            + cellLayoutPaddingPx.left,
+                    hotseatBarSizePx - hotseatBarBottomPadding - hotseatCellHeightPx,
+                    remainingSpaceOnSide + mInsets.right + workspacePadding.right
+                            + cellLayoutPaddingPx.right,
+                    hotseatBarBottomPadding
+            );
+        } else if (isTaskbarPresent) {
             // Center the QSB vertically with hotseat
             int hotseatBarBottomPadding = getHotseatBarBottomPadding();
             int hotseatBarTopPadding =
@@ -1950,11 +1976,6 @@
             }
             startSpacing += getAdditionalQsbSpace();
 
-            if (inv.isFixedLandscape) {
-                endSpacing += mInsets.right;
-                startSpacing +=  mInsets.left;
-            }
-
             hotseatBarPadding.top = hotseatBarTopPadding;
             hotseatBarPadding.bottom = hotseatBarBottomPadding;
             boolean isRtl = Utilities.isRtl(context.getResources());
@@ -2164,7 +2185,8 @@
     }
 
     public boolean isSeascape() {
-        return rotationHint == Surface.ROTATION_270 && isVerticalBarLayout();
+        return rotationHint == Surface.ROTATION_270
+                && (isVerticalBarLayout() || inv.isFixedLandscape);
     }
 
     public boolean shouldFadeAdjacentWorkspaceScreens() {
diff --git a/src/com/android/launcher3/Launcher.java b/src/com/android/launcher3/Launcher.java
index 289f175..d5b3ed5 100644
--- a/src/com/android/launcher3/Launcher.java
+++ b/src/com/android/launcher3/Launcher.java
@@ -532,11 +532,14 @@
         mAllAppsController = new AllAppsTransitionController(this);
         mStateManager = new StateManager<>(this, NORMAL);
 
+        mAppWidgetManager = new WidgetManagerHelper(this);
+        mAppWidgetHolder = LauncherWidgetHolder.newInstance(this);
+        mAppWidgetHolder.setAppWidgetRemovedCallback(
+                appWidgetId -> getWorkspace().removeWidget(appWidgetId));
+
         setupViews();
         updateDisallowBack();
 
-        mAppWidgetManager = new WidgetManagerHelper(this);
-        mAppWidgetHolder = createAppWidgetHolder();
         mAppWidgetHolder.startListening();
         mAppWidgetHolder.addProviderChangeListener(() -> refreshAndBindWidgetsForPackageUser(null));
         mItemInflater = new ItemInflater<>(this, mAppWidgetHolder, getItemOnClickListener(),
@@ -1472,8 +1475,7 @@
             // Adding a shortcut to a Folder.
             FolderIcon folderIcon = findFolderIcon(container);
             if (folderIcon != null) {
-                FolderInfo folderInfo = (FolderInfo) folderIcon.getTag();
-                folderInfo.add(info, args.rank, false);
+                folderIcon.getFolder().addFolderContent(info, args.rank, false);
             } else {
                 Log.e(TAG, "Could not find folder with id " + container + " to add shortcut.");
             }
@@ -1615,11 +1617,6 @@
         return instance;
     }
 
-    protected LauncherWidgetHolder createAppWidgetHolder() {
-        return LauncherWidgetHolder.HolderFactory.newFactory(this).newInstance(
-                this, appWidgetId -> getWorkspace().removeWidget(appWidgetId));
-    }
-
     @Override
     protected void onNewIntent(Intent intent) {
         if (Utilities.isRunningInTestHarness()) {
@@ -1792,7 +1789,6 @@
         SettingsCache.INSTANCE.get(this).unregister(TOUCHPAD_NATURAL_SCROLLING,
                 mNaturalScrollingChangedListener);
         ScreenOnTracker.INSTANCE.get(this).removeListener(mScreenOnListener);
-        mWorkspace.removeFolderListeners();
         PluginManagerWrapper.INSTANCE.get(this).removePluginListener(this);
 
         mModel.removeCallbacks(this);
@@ -2053,9 +2049,10 @@
             @Nullable final String reason) {
         if (itemInfo instanceof WorkspaceItemInfo) {
             View collectionIcon = mWorkspace.getViewByItemId(itemInfo.container);
-            if (collectionIcon instanceof FolderIcon) {
+            if (collectionIcon instanceof FolderIcon folderIcon) {
                 // Remove the shortcut from the folder before removing it from launcher
-                ((FolderInfo) collectionIcon.getTag()).remove((WorkspaceItemInfo) itemInfo, true);
+                Folder folder = folderIcon.getFolder();
+                folder.removeFolderContent(true, itemInfo);
             } else if (collectionIcon instanceof AppPairIcon appPairIcon) {
                 removeItem(appPairIcon, appPairIcon.getInfo(), deleteFromDb,
                         "removing app pair because one of its member apps was removed");
@@ -2066,9 +2063,6 @@
                 getModelWriter().deleteItemFromDatabase(itemInfo, reason);
             }
         } else if (itemInfo instanceof CollectionInfo ci) {
-            if (v instanceof FolderIcon) {
-                ((FolderIcon) v).removeListeners();
-            }
             mWorkspace.removeWorkspaceItem(v);
             if (deleteFromDb) {
                 getModelWriter().deleteCollectionAndContentsFromDatabase(ci);
diff --git a/src/com/android/launcher3/LauncherModel.kt b/src/com/android/launcher3/LauncherModel.kt
index add0ad8..557ad67 100644
--- a/src/com/android/launcher3/LauncherModel.kt
+++ b/src/com/android/launcher3/LauncherModel.kt
@@ -28,11 +28,12 @@
 import com.android.launcher3.icons.IconCache
 import com.android.launcher3.model.AddWorkspaceItemsTask
 import com.android.launcher3.model.AllAppsList
-import com.android.launcher3.model.BaseLauncherBinder
+import com.android.launcher3.model.BaseLauncherBinder.BaseLauncherBinderFactory
 import com.android.launcher3.model.BgDataModel
 import com.android.launcher3.model.CacheDataUpdatedTask
 import com.android.launcher3.model.ItemInstallQueue
 import com.android.launcher3.model.LoaderTask
+import com.android.launcher3.model.LoaderTask.LoaderTaskFactory
 import com.android.launcher3.model.ModelDbController
 import com.android.launcher3.model.ModelDelegate
 import com.android.launcher3.model.ModelInitializer
@@ -43,6 +44,8 @@
 import com.android.launcher3.model.ReloadStringCacheTask
 import com.android.launcher3.model.ShortcutsChangedTask
 import com.android.launcher3.model.UserLockStateChangedTask
+import com.android.launcher3.model.UserManagerState
+import com.android.launcher3.model.WorkspaceItemSpaceFinder
 import com.android.launcher3.model.data.ItemInfo
 import com.android.launcher3.model.data.WorkspaceItemInfo
 import com.android.launcher3.pm.UserCache
@@ -70,30 +73,24 @@
 @Inject
 constructor(
     @ApplicationContext private val context: Context,
-    private val appProvider: Provider<LauncherAppState>,
+    private val taskControllerProvider: Provider<ModelTaskController>,
     private val iconCache: IconCache,
     private val prefs: LauncherPrefs,
     private val installQueue: ItemInstallQueue,
-    appFilter: AppFilter,
     @Named("ICONS_DB") dbFileName: String?,
     initializer: ModelInitializer,
     lifecycle: DaggerSingletonTracker,
     val modelDelegate: ModelDelegate,
+    private val mBgAllAppsList: AllAppsList,
+    private val mBgDataModel: BgDataModel,
+    private val loaderFactory: LoaderTaskFactory,
+    private val binderFactory: BaseLauncherBinderFactory,
+    private val spaceFinderFactory: Provider<WorkspaceItemSpaceFinder>,
+    val modelDbController: ModelDbController,
 ) {
 
     private val mCallbacksList = ArrayList<BgDataModel.Callbacks>(1)
 
-    // < only access in worker thread >
-    private val mBgAllAppsList = AllAppsList(iconCache, appFilter)
-
-    /**
-     * All the static data should be accessed on the background thread, A lock should be acquired on
-     * this object when accessing any data from this model.
-     */
-    private val mBgDataModel = BgDataModel()
-
-    val modelDbController = ModelDbController(context)
-
     private val mLock = Any()
 
     private var mLoaderTask: LoaderTask? = null
@@ -139,7 +136,7 @@
     /** Adds the provided items to the workspace. */
     fun addAndBindAddedWorkspaceItems(itemList: List<Pair<ItemInfo?, Any?>?>) {
         callbacks.forEach { it.preAddApps() }
-        enqueueModelUpdateTask(AddWorkspaceItemsTask(itemList))
+        enqueueModelUpdateTask(AddWorkspaceItemsTask(itemList, spaceFinderFactory.get()))
     }
 
     fun getWriter(
@@ -299,13 +296,7 @@
                 // Clear any pending bind-runnables from the synchronized load process.
                 callbacksList.forEach { MAIN_EXECUTOR.execute(it::clearPendingBinds) }
 
-                val launcherBinder =
-                    BaseLauncherBinder(
-                        appProvider.get(),
-                        mBgDataModel,
-                        mBgAllAppsList,
-                        callbacksList,
-                    )
+                val launcherBinder = binderFactory.createBinder(callbacksList)
                 if (bindDirectly) {
                     // Divide the set of loaded items into those that we are binding synchronously,
                     // and everything else that is to be bound normally (asynchronously).
@@ -317,14 +308,7 @@
                     launcherBinder.bindWidgets()
                     return true
                 } else {
-                    val task =
-                        LoaderTask(
-                            appProvider.get(),
-                            mBgAllAppsList,
-                            mBgDataModel,
-                            this.modelDelegate,
-                            launcherBinder,
-                        )
+                    val task = loaderFactory.newLoaderTask(launcherBinder, UserManagerState())
                     mLoaderTask = task
 
                     // Always post the loader task, instead of running directly
@@ -425,7 +409,7 @@
     /** Called when the labels for the widgets has updated in the icon cache. */
     fun onWidgetLabelsUpdated(updatedPackages: HashSet<String?>, user: UserHandle) {
         enqueueModelUpdateTask { taskController, dataModel, _ ->
-            dataModel.widgetsModel.onPackageIconsUpdated(updatedPackages, user, appProvider.get())
+            dataModel.widgetsModel.onPackageIconsUpdated(updatedPackages, user)
             taskController.bindUpdatedWidgets(dataModel)
         }
     }
@@ -439,17 +423,7 @@
                 // Loader has not yet run.
                 return@execute
             }
-            task.execute(
-                ModelTaskController(
-                    appProvider.get(),
-                    mBgDataModel,
-                    mBgAllAppsList,
-                    this,
-                    MAIN_EXECUTOR,
-                ),
-                mBgDataModel,
-                mBgAllAppsList,
-            )
+            task.execute(taskControllerProvider.get(), mBgDataModel, mBgAllAppsList)
         }
     }
 
@@ -476,7 +450,7 @@
 
     fun refreshAndBindWidgetsAndShortcuts(packageUser: PackageUserKey?) {
         enqueueModelUpdateTask { taskController, dataModel, _ ->
-            dataModel.widgetsModel.update(taskController.app, packageUser)
+            dataModel.widgetsModel.update(packageUser)
             taskController.bindUpdatedWidgets(dataModel)
         }
     }
diff --git a/src/com/android/launcher3/LauncherProvider.java b/src/com/android/launcher3/LauncherProvider.java
index 03ecf14..acb2b48 100644
--- a/src/com/android/launcher3/LauncherProvider.java
+++ b/src/com/android/launcher3/LauncherProvider.java
@@ -26,13 +26,13 @@
 import android.content.ContentValues;
 import android.content.pm.PackageManager;
 import android.database.Cursor;
-import android.database.sqlite.SQLiteQueryBuilder;
 import android.net.Uri;
 import android.os.Binder;
 import android.os.Bundle;
 import android.os.Process;
 import android.text.TextUtils;
 import android.util.Log;
+import android.util.Pair;
 
 import com.android.launcher3.LauncherSettings.Favorites;
 import com.android.launcher3.model.ModelDbController;
@@ -74,24 +74,20 @@
 
     @Override
     public String getType(Uri uri) {
-        SqlArguments args = new SqlArguments(uri, null, null);
-        if (TextUtils.isEmpty(args.where)) {
-            return "vnd.android.cursor.dir/" + args.table;
+        if (TextUtils.isEmpty(parseUri(uri, null, null).first)) {
+            return "vnd.android.cursor.dir/" + Favorites.TABLE_NAME;
         } else {
-            return "vnd.android.cursor.item/" + args.table;
+            return "vnd.android.cursor.item/" + Favorites.TABLE_NAME;
         }
     }
 
     @Override
     public Cursor query(Uri uri, String[] projection, String selection,
             String[] selectionArgs, String sortOrder) {
-        SqlArguments args = new SqlArguments(uri, selection, selectionArgs);
-        SQLiteQueryBuilder qb = new SQLiteQueryBuilder();
-        qb.setTables(args.table);
-
+        Pair<String, String[]> args = parseUri(uri, selection, selectionArgs);
         Cursor[] result = new Cursor[1];
         executeControllerTask(controller -> {
-            result[0] = controller.query(args.table, projection, args.where, args.args, sortOrder);
+            result[0] = controller.query(projection, args.first, args.second, sortOrder);
             return 0;
         });
         return result[0];
@@ -108,7 +104,7 @@
             // attempt allocate and bind the widget.
             Integer itemType = values.getAsInteger(Favorites.ITEM_TYPE);
             if (itemType != null
-                    && itemType.intValue() == Favorites.ITEM_TYPE_APPWIDGET
+                    && itemType == Favorites.ITEM_TYPE_APPWIDGET
                     && !values.containsKey(Favorites.APPWIDGET_ID)) {
 
                 ComponentName cn = ComponentName.unflattenFromString(
@@ -135,8 +131,7 @@
                 }
             }
 
-            SqlArguments args = new SqlArguments(uri);
-            return controller.insert(args.table, values);
+            return controller.insert(values);
         });
 
         return rowId < 0 ? null : ContentUris.withAppendedId(uri, rowId);
@@ -144,14 +139,14 @@
 
     @Override
     public int delete(Uri uri, String selection, String[] selectionArgs) {
-        SqlArguments args = new SqlArguments(uri, selection, selectionArgs);
-        return executeControllerTask(c -> c.delete(args.table, args.where, args.args));
+        Pair<String, String[]> args = parseUri(uri, selection, selectionArgs);
+        return executeControllerTask(c -> c.delete(args.first, args.second));
     }
 
     @Override
     public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
-        SqlArguments args = new SqlArguments(uri, selection, selectionArgs);
-        return executeControllerTask(c -> c.update(args.table, values, args.where, args.args));
+        Pair<String, String[]> args = parseUri(uri, selection, selectionArgs);
+        return executeControllerTask(c -> c.update(values, args.first, args.second));
     }
 
     @Override
@@ -209,35 +204,24 @@
         }
     }
 
-    static class SqlArguments {
-        public final String table;
-        public final String where;
-        public final String[] args;
-
-        SqlArguments(Uri url, String where, String[] args) {
-            if (url.getPathSegments().size() == 1) {
-                this.table = url.getPathSegments().get(0);
-                this.where = where;
-                this.args = args;
-            } else if (url.getPathSegments().size() != 2) {
-                throw new IllegalArgumentException("Invalid URI: " + url);
-            } else if (!TextUtils.isEmpty(where)) {
-                throw new UnsupportedOperationException("WHERE clause not supported: " + url);
-            } else {
-                this.table = url.getPathSegments().get(0);
-                this.where = "_id=" + ContentUris.parseId(url);
-                this.args = null;
+    /**
+     * Parses the uri and returns the where and arg clause.
+     *
+     * Note: This should be called on the binder thread (before posting on any executor) so that
+     * any parsing error gets propagated to the caller.
+     */
+    private static Pair<String, String[]> parseUri(Uri url, String where, String[] args) {
+        switch (url.getPathSegments().size()) {
+            case 1 -> {
+                return Pair.create(where, args);
             }
-        }
-
-        SqlArguments(Uri url) {
-            if (url.getPathSegments().size() == 1) {
-                table = url.getPathSegments().get(0);
-                where = null;
-                args = null;
-            } else {
-                throw new IllegalArgumentException("Invalid URI: " + url);
+            case 2 -> {
+                if (!TextUtils.isEmpty(where)) {
+                    throw new UnsupportedOperationException("WHERE clause not supported: " + url);
+                }
+                return Pair.create("_id=" + ContentUris.parseId(url), null);
             }
+            default -> throw new IllegalArgumentException("Invalid URI: " + url);
         }
     }
 }
diff --git a/src/com/android/launcher3/Utilities.java b/src/com/android/launcher3/Utilities.java
index 9a9bc1d..d6ae3a6 100644
--- a/src/com/android/launcher3/Utilities.java
+++ b/src/com/android/launcher3/Utilities.java
@@ -100,6 +100,7 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.Locale;
+import java.util.Objects;
 import java.util.function.Predicate;
 
 /**
@@ -276,8 +277,12 @@
      */
     public static void mapCoordInSelfToDescendant(View descendant, View root, float[] coord) {
         sMatrix.reset();
+        //TODO(b/307488755) when implemented this check should be removed
+        if (!Objects.equals(descendant.getWindowId(), root.getWindowId())) {
+            return;
+        }
         View v = descendant;
-        while(v != root) {
+        while (v != root) {
             sMatrix.postTranslate(-v.getScrollX(), -v.getScrollY());
             sMatrix.postConcat(v.getMatrix());
             sMatrix.postTranslate(v.getLeft(), v.getTop());
diff --git a/src/com/android/launcher3/Workspace.java b/src/com/android/launcher3/Workspace.java
index 6ed183a..59f84ab 100644
--- a/src/com/android/launcher3/Workspace.java
+++ b/src/com/android/launcher3/Workspace.java
@@ -137,7 +137,6 @@
 import java.util.List;
 import java.util.function.Consumer;
 import java.util.function.Predicate;
-import java.util.stream.Collectors;
 
 /**
  * The workspace is a wide area with a wallpaper and a finite number of pages.
@@ -659,7 +658,6 @@
         }
 
         // Remove the pages and clear the screen models
-        removeFolderListeners();
         removeAllViews();
         mScreenOrder.clear();
         mWorkspaceScreens.clear();
@@ -1914,7 +1912,7 @@
 
         boolean aboveShortcut = Folder.willAccept(dropOverView.getTag())
                 && ((ItemInfo) dropOverView.getTag()).container != CONTAINER_HOTSEAT_PREDICTION;
-        boolean willBecomeShortcut = Folder.willAcceptItemType(info.itemType);
+        boolean willBecomeShortcut = FolderInfo.willAcceptItemType(info.itemType);
 
         return (aboveShortcut && willBecomeShortcut);
     }
@@ -1994,8 +1992,8 @@
                 fi.performCreateAnimation(destInfo, v, sourceInfo, d, folderLocation, scale);
             } else {
                 fi.prepareCreateAnimation(v);
-                fi.addItem(destInfo);
-                fi.addItem(sourceInfo);
+                fi.getFolder().addFolderContent(destInfo);
+                fi.getFolder().addFolderContent(sourceInfo);
             }
             return true;
         }
@@ -3209,21 +3207,6 @@
         });
     }
 
-    /**
-     * Removes all folder listeners
-     */
-    public void removeFolderListeners() {
-        mapOverItems(new ItemOperator() {
-            @Override
-            public boolean evaluate(ItemInfo info, View view) {
-                if (view instanceof FolderIcon) {
-                    ((FolderIcon) view).removeListeners();
-                }
-                return false;
-            }
-        });
-    }
-
     public boolean isDropEnabled() {
         return true;
     }
@@ -3349,15 +3332,15 @@
                     if (child instanceof DropTarget) {
                         mDragController.removeDropTarget((DropTarget) child);
                     }
-                } else if (child instanceof FolderIcon) {
+                } else if (child instanceof FolderIcon folderIcon) {
                     FolderInfo folderInfo = (FolderInfo) info;
-                    List<ItemInfo> matches = folderInfo.getContents().stream()
+                    ItemInfo[] matches = folderInfo.getContents().stream()
                             .filter(matcher)
-                            .collect(Collectors.toList());
-                    if (!matches.isEmpty()) {
-                        folderInfo.removeAll(matches, false);
-                        if (((FolderIcon) child).getFolder().isOpen()) {
-                            ((FolderIcon) child).getFolder().close(false /* animate */);
+                            .toArray(ItemInfo[]::new);
+                    if (matches.length > 0) {
+                        folderIcon.getFolder().removeFolderContent(false, matches);
+                        if (folderIcon.getFolder().isOpen()) {
+                            folderIcon.getFolder().close(false /* animate */);
                         }
                     }
                 } else if (info instanceof AppPairInfo api) {
diff --git a/src/com/android/launcher3/accessibility/LauncherAccessibilityDelegate.java b/src/com/android/launcher3/accessibility/LauncherAccessibilityDelegate.java
index 78b53a9..df34ccf 100644
--- a/src/com/android/launcher3/accessibility/LauncherAccessibilityDelegate.java
+++ b/src/com/android/launcher3/accessibility/LauncherAccessibilityDelegate.java
@@ -25,6 +25,7 @@
 import androidx.annotation.Nullable;
 
 import com.android.launcher3.AbstractFloatingView;
+import com.android.launcher3.AppWidgetResizeFrame;
 import com.android.launcher3.BubbleTextView;
 import com.android.launcher3.ButtonDropTarget;
 import com.android.launcher3.CellLayout;
@@ -82,6 +83,7 @@
     protected static final int MOVE_TO_WORKSPACE = R.id.action_move_to_workspace;
     protected static final int RESIZE = R.id.action_resize;
     public static final int DEEP_SHORTCUTS = R.id.action_deep_shortcuts;
+    public static final int CLOSE = R.id.action_close;
 
     public LauncherAccessibilityDelegate(Launcher launcher) {
         super(launcher);
@@ -104,6 +106,8 @@
                 RESIZE, R.string.action_resize, KeyEvent.KEYCODE_R));
         mActions.put(DEEP_SHORTCUTS, new LauncherAction(DEEP_SHORTCUTS,
                 R.string.action_deep_shortcut, KeyEvent.KEYCODE_S));
+        mActions.put(CLOSE, new LauncherAction(CLOSE,
+                R.string.action_close, KeyEvent.KEYCODE_X));
     }
 
     private static boolean isNotInShortcutMenu(@Nullable View view) {
@@ -137,6 +141,10 @@
             }
         }
 
+        if (host instanceof AppWidgetResizeFrame) {
+            out.add(mActions.get(CLOSE));
+        }
+
         if (supportAddToWorkSpace(item)) {
             out.add(mActions.get(ADD_TO_WORKSPACE));
         }
@@ -183,22 +191,28 @@
             }
             return dragCondition != null;
         } else if (action == MOVE) {
-            return beginAccessibleDrag(host, item, fromKeyboard);
+            final View itemView = (host instanceof AppWidgetResizeFrame)
+                    ? ((AppWidgetResizeFrame) host).getViewForAccessibility()
+                    : host;
+            return beginAccessibleDrag(itemView, item, fromKeyboard);
         } else if (action == ADD_TO_WORKSPACE) {
             return addToWorkspace(item, true /*accessibility*/, null /*finishCallback*/);
         } else if (action == MOVE_TO_WORKSPACE) {
             return moveToWorkspace(item);
         } else if (action == RESIZE) {
+            final View itemView = (host instanceof AppWidgetResizeFrame)
+                    ? ((AppWidgetResizeFrame) host).getViewForAccessibility()
+                    : host;
             final LauncherAppWidgetInfo info = (LauncherAppWidgetInfo) item;
-            List<OptionItem> actions = getSupportedResizeActions(host, info);
+            List<OptionItem> actions = getSupportedResizeActions(itemView, info);
             Rect pos = new Rect();
-            mContext.getDragLayer().getDescendantRectRelativeToSelf(host, pos);
+            mContext.getDragLayer().getDescendantRectRelativeToSelf(itemView, pos);
             ArrowPopup popup = OptionsPopupView.show(mContext, new RectF(pos), actions, false);
             popup.requestFocus();
             popup.addOnCloseCallback(() -> {
-                host.requestFocus();
-                host.sendAccessibilityEvent(TYPE_VIEW_FOCUSED);
-                host.performAccessibilityAction(ACTION_ACCESSIBILITY_FOCUS, null);
+                itemView.requestFocus();
+                itemView.sendAccessibilityEvent(TYPE_VIEW_FOCUSED);
+                itemView.performAccessibilityAction(ACTION_ACCESSIBILITY_FOCUS, null);
                 AbstractFloatingView.closeOpenViews(mContext, /* animate= */ false,
                         AbstractFloatingView.TYPE_WIDGET_RESIZE_FRAME);
             });
@@ -208,6 +222,11 @@
                     : (host instanceof BubbleTextHolder
                             ? ((BubbleTextHolder) host).getBubbleText() : null);
             return btv != null && PopupContainerWithArrow.showForIcon(btv) != null;
+        } else if (action == CLOSE) {
+            if (host instanceof AppWidgetResizeFrame) {
+                AbstractFloatingView.closeOpenViews(mContext, /* animate= */ false,
+                        AbstractFloatingView.TYPE_WIDGET_RESIZE_FRAME);
+            }
         } else {
             for (ButtonDropTarget dropTarget : mContext.getDropTargetBar().getDropTargets()) {
                 if (dropTarget.supportsAccessibilityDrop(item, host)
@@ -222,6 +241,10 @@
 
     private List<OptionItem> getSupportedResizeActions(View host, LauncherAppWidgetInfo info) {
         List<OptionItem> actions = new ArrayList<>();
+        if (host instanceof AppWidgetResizeFrame) {
+            return getSupportedResizeActions(
+                    ((AppWidgetResizeFrame) host).getViewForAccessibility(), info);
+        }
         AppWidgetProviderInfo providerInfo = ((LauncherAppWidgetHostView) host).getAppWidgetInfo();
         if (providerInfo == null) {
             return actions;
@@ -496,7 +519,7 @@
         Folder folder = Folder.getOpen(mContext);
         folder.close(true);
         WorkspaceItemInfo info = (WorkspaceItemInfo) item;
-        folder.getInfo().remove(info, false);
+        folder.removeFolderContent(false, info);
 
         final int[] coordinates = new int[2];
         final int screenId = findSpaceOnWorkspace(item, coordinates);
diff --git a/src/com/android/launcher3/allapps/ActivityAllAppsContainerView.java b/src/com/android/launcher3/allapps/ActivityAllAppsContainerView.java
index fafa60b..f60896e 100644
--- a/src/com/android/launcher3/allapps/ActivityAllAppsContainerView.java
+++ b/src/com/android/launcher3/allapps/ActivityAllAppsContainerView.java
@@ -181,6 +181,7 @@
     private ScrimView mScrimView;
     private int mHeaderColor;
     private int mBottomSheetBackgroundColor;
+    private float mBottomSheetBackgroundAlpha = 1f;
     private int mTabsProtectionAlpha;
     @Nullable private AllAppsTransitionController mAllAppsTransitionController;
 
@@ -311,7 +312,17 @@
                 0,
                 0 // Bottom left
         };
-        mBottomSheetBackgroundColor = getContext().getColor(R.color.materialColorSurfaceDim);
+        if (Flags.allAppsBlur()) {
+            int resId = Utilities.isDarkTheme(getContext())
+                    ? android.R.color.system_accent1_800 : android.R.color.system_accent1_100;
+            int layerAbove = ColorUtils.setAlphaComponent(getResources().getColor(resId, null),
+                    (int) (0.4f * 255));
+            int layerBelow = ColorUtils.setAlphaComponent(Color.WHITE, (int) (0.1f * 255));
+            mBottomSheetBackgroundColor = ColorUtils.compositeColors(layerAbove, layerBelow);
+        } else {
+            mBottomSheetBackgroundColor = getContext().getColor(R.color.materialColorSurfaceDim);
+        }
+        mBottomSheetBackgroundAlpha = Color.alpha(mBottomSheetBackgroundColor) / 255.0f;
         updateBackgroundVisibility(mActivityContext.getDeviceProfile());
         mSearchUiManager.initializeSearch(this);
     }
@@ -1152,7 +1163,7 @@
 
         if (!grid.isVerticalBarLayout() || FeatureFlags.enableResponsiveWorkspace()) {
             int topPadding = grid.allAppsPadding.top;
-            if (isSearchBarFloating() && !grid.isTablet) {
+            if (isSearchBarFloating() && !grid.shouldShowAllAppsOnSheet()) {
                 topPadding += getResources().getDimensionPixelSize(
                         R.dimen.all_apps_additional_top_padding_floating_search);
             }
@@ -1401,7 +1412,7 @@
         // Draw full background panel for tablets.
         if (hasBottomSheet) {
             mHeaderPaint.setColor(mBottomSheetBackgroundColor);
-            mHeaderPaint.setAlpha(255);
+            mHeaderPaint.setAlpha((int) (mBottomSheetBackgroundAlpha * 255));
 
             mTmpRectF.set(
                     leftWithScale,
@@ -1424,6 +1435,10 @@
             return;
         }
 
+        if (hasBottomSheet) {
+            mHeaderPaint.setAlpha((int) (mHeaderPaint.getAlpha() * mBottomSheetBackgroundAlpha));
+        }
+
         // Draw header on background panel
         final float headerBottomNoScale =
                 getHeaderBottom() + getVisibleContainerView().getPaddingTop();
@@ -1455,7 +1470,11 @@
                 mHeaderPaint.setColor(Color.BLUE);
                 mHeaderPaint.setAlpha(255);
             } else {
-                mHeaderPaint.setAlpha((int) (getAlpha() * mTabsProtectionAlpha));
+                float tabAlpha = getAlpha() * mTabsProtectionAlpha;
+                if (hasBottomSheet) {
+                    tabAlpha *= mBottomSheetBackgroundAlpha;
+                }
+                mHeaderPaint.setAlpha((int) tabAlpha);
             }
             float left = 0f;
             float right = canvas.getWidth();
@@ -1507,7 +1526,7 @@
     public int getHeaderBottom() {
         int bottom = (int) getTranslationY() + mHeader.getClipTop();
         if (isSearchBarFloating()) {
-            if (mActivityContext.getDeviceProfile().isTablet) {
+            if (mActivityContext.getDeviceProfile().shouldShowAllAppsOnSheet()) {
                 return bottom + mBottomSheetBackground.getTop();
             }
             return bottom;
diff --git a/src/com/android/launcher3/allapps/AllAppsTransitionController.java b/src/com/android/launcher3/allapps/AllAppsTransitionController.java
index 4cc31d2..350f763 100644
--- a/src/com/android/launcher3/allapps/AllAppsTransitionController.java
+++ b/src/com/android/launcher3/allapps/AllAppsTransitionController.java
@@ -290,7 +290,8 @@
     private void onScaleProgressChanged() {
         final float scaleProgress = mAllAppScale.value;
         SCALE_PROPERTY.set(mLauncher.getAppsView(), scaleProgress);
-        if (!mLauncher.getAppsView().isSearching() || !mLauncher.getDeviceProfile().isTablet) {
+        if (!mLauncher.getAppsView().isSearching()
+                || !mLauncher.getDeviceProfile().shouldShowAllAppsOnSheet()) {
             mLauncher.getScrimView().setScrimHeaderScale(scaleProgress);
         }
 
diff --git a/src/com/android/launcher3/allapps/AlphabeticalAppsList.java b/src/com/android/launcher3/allapps/AlphabeticalAppsList.java
index 5f632fe..bf02e03 100644
--- a/src/com/android/launcher3/allapps/AlphabeticalAppsList.java
+++ b/src/com/android/launcher3/allapps/AlphabeticalAppsList.java
@@ -64,7 +64,7 @@
         AllAppsStore.OnUpdateListener {
 
     public static final String TAG = "AlphabeticalAppsList";
-    private static final String PRIVATE_SPACE_PACKAGE = "com.android.privatespace";
+    public static final String PRIVATE_SPACE_PACKAGE = "com.android.privatespace";
 
     private final WorkProfileManager mWorkProviderManager;
 
@@ -435,7 +435,10 @@
                 }
                 if (currentItem.itemInfo != null && Objects.equals(
                         currentItem.itemInfo.getTargetPackage(), PRIVATE_SPACE_PACKAGE)) {
+                    currentItem.itemInfo.bitmap = mPrivateProviderManager.preparePSBitmapInfo();
                     currentItem.itemInfo.bitmap.creationFlags |= FLAG_NO_BADGE;
+                    currentItem.itemInfo.contentDescription =
+                            mPrivateProviderManager.getPsAppContentDesc();
                     privateSpaceAppIndex = i;
                 }
             }
diff --git a/src/com/android/launcher3/allapps/PrivateProfileManager.java b/src/com/android/launcher3/allapps/PrivateProfileManager.java
index 609edd2..0e6a5b8 100644
--- a/src/com/android/launcher3/allapps/PrivateProfileManager.java
+++ b/src/com/android/launcher3/allapps/PrivateProfileManager.java
@@ -142,6 +142,7 @@
     private PrivateSpaceSettingsButton mPrivateSpaceSettingsButton;
     @Nullable
     private ConstraintLayout mFloatingMaskView;
+    private final String mPrivateSpaceAppContentDesc;
     private final String mLockedStateContentDesc;
     private final String mUnLockedStateContentDesc;
 
@@ -157,6 +158,8 @@
         UI_HELPER_EXECUTOR.post(() -> initializeInBackgroundThread(appContext));
         mPsHeaderHeight = mAllApps.getContext().getResources().getDimensionPixelSize(
                 R.dimen.ps_header_height);
+        mPrivateSpaceAppContentDesc = mAllApps.getContext()
+                .getString(R.string.ps_app_content_description);
         mLockedStateContentDesc = mAllApps.getContext()
                 .getString(R.string.ps_container_lock_button_content_description);
         mUnLockedStateContentDesc = mAllApps.getContext()
@@ -187,15 +190,11 @@
     /** Adds Private Space install app button to the layout. */
     public void addPrivateSpaceInstallAppButton(List<BaseAllAppsAdapter.AdapterItem> adapterItems) {
         Context context = mAllApps.getContext();
-        // Prepare bitmapInfo
-        Intent.ShortcutIconResource shortcut = Intent.ShortcutIconResource.fromContext(
-                context, com.android.launcher3.R.drawable.private_space_install_app_icon);
-        BitmapInfo bitmapInfo = LauncherIcons.obtain(context).createIconBitmap(shortcut);
 
         PrivateSpaceInstallAppButtonInfo itemInfo = new PrivateSpaceInstallAppButtonInfo();
         itemInfo.title = context.getResources().getString(R.string.ps_add_button_label);
         itemInfo.intent = mAppInstallerIntent;
-        itemInfo.bitmap = bitmapInfo;
+        itemInfo.bitmap = preparePSBitmapInfo();
         itemInfo.contentDescription = context.getResources().getString(
                 com.android.launcher3.R.string.ps_add_button_content_description);
         itemInfo.runtimeStatusFlags |= FLAG_NOT_PINNABLE;
@@ -215,6 +214,13 @@
                     .get(mAllApps.getContext()).getValue(PRIVATE_SPACE_HIDE_WHEN_LOCKED_URI, 0);
     }
 
+    BitmapInfo preparePSBitmapInfo() {
+        Context context = mAllApps.getContext();
+        Intent.ShortcutIconResource shortcut = Intent.ShortcutIconResource.fromContext(
+                context, com.android.launcher3.R.drawable.private_space_install_app_icon);
+        return LauncherIcons.obtain(context).createIconBitmap(shortcut);
+    }
+
     /**
      * Resets the current state of Private Profile, w.r.t. to Launcher. The decorator should only
      * be applied upon expand before animating. When collapsing, reset() will remove the decorator
@@ -929,6 +935,10 @@
         return mPsHeaderHeight;
     }
 
+    String getPsAppContentDesc() {
+        return mPrivateSpaceAppContentDesc;
+    }
+
     boolean isPrivateSpaceItem(BaseAllAppsAdapter.AdapterItem item) {
         return getItemInfoMatcher().test(item.itemInfo) || item.decorationInfo != null
                 || (item.itemInfo instanceof PrivateSpaceInstallAppButtonInfo);
diff --git a/src/com/android/launcher3/config/FeatureFlags.java b/src/com/android/launcher3/config/FeatureFlags.java
index 44dcc06..d987841 100644
--- a/src/com/android/launcher3/config/FeatureFlags.java
+++ b/src/com/android/launcher3/config/FeatureFlags.java
@@ -163,11 +163,6 @@
             "ENABLE_WIDGET_TRANSITION_FOR_RESIZING", DISABLED,
             "Enable widget transition animation when resizing the widgets");
 
-    // TODO(Block 25): Clean up flags
-    public static final BooleanFlag ENABLE_WIDGET_HOST_IN_BACKGROUND = getDebugFlag(270394384,
-            "ENABLE_WIDGET_HOST_IN_BACKGROUND", ENABLED,
-            "Enable background widget updates listening for widget holder");
-
     // TODO(Block 27): Clean up flags
     public static final BooleanFlag ENABLE_OVERLAY_CONNECTION_OPTIM = getDebugFlag(270392629,
             "ENABLE_OVERLAY_CONNECTION_OPTIM", DISABLED,
diff --git a/src/com/android/launcher3/dagger/LauncherAppModule.java b/src/com/android/launcher3/dagger/LauncherAppModule.java
index c58a414..0fd3219 100644
--- a/src/com/android/launcher3/dagger/LauncherAppModule.java
+++ b/src/com/android/launcher3/dagger/LauncherAppModule.java
@@ -23,6 +23,7 @@
         ApiWrapperModule.class,
         PluginManagerWrapperModule.class,
         StaticObjectModule.class,
+        WidgetModule.class,
         AppModule.class
 })
 public class LauncherAppModule {
diff --git a/src/com/android/launcher3/dagger/LauncherBaseAppComponent.java b/src/com/android/launcher3/dagger/LauncherBaseAppComponent.java
index 06643d3..f86772e 100644
--- a/src/com/android/launcher3/dagger/LauncherBaseAppComponent.java
+++ b/src/com/android/launcher3/dagger/LauncherBaseAppComponent.java
@@ -28,6 +28,7 @@
 import com.android.launcher3.graphics.ThemeManager;
 import com.android.launcher3.icons.LauncherIcons.IconPool;
 import com.android.launcher3.model.ItemInstallQueue;
+import com.android.launcher3.model.LoaderCursor.LoaderCursorFactory;
 import com.android.launcher3.model.WidgetsFilterDataProvider;
 import com.android.launcher3.pm.InstallSessionHelper;
 import com.android.launcher3.pm.UserCache;
@@ -45,6 +46,7 @@
 import com.android.launcher3.util.WallpaperColorHints;
 import com.android.launcher3.util.window.RefreshRateTracker;
 import com.android.launcher3.util.window.WindowManagerProxy;
+import com.android.launcher3.widget.LauncherWidgetHolder.WidgetHolderFactory;
 import com.android.launcher3.widget.custom.CustomWidgetManager;
 
 import dagger.BindsInstance;
@@ -87,6 +89,9 @@
     GridCustomizationsProxy getGridCustomizationsProxy();
     WidgetsFilterDataProvider getWidgetsFilterDataProvider();
 
+    LoaderCursorFactory getLoaderCursorFactory();
+    WidgetHolderFactory getWidgetHolderFactory();
+
     /** Builder for LauncherBaseAppComponent. */
     interface Builder {
         @BindsInstance Builder appContext(@ApplicationContext Context context);
diff --git a/src/com/android/launcher3/debug/TestEventEmitter.java b/src/com/android/launcher3/debug/TestEventEmitter.java
index ed3b4bb..db69bc2 100644
--- a/src/com/android/launcher3/debug/TestEventEmitter.java
+++ b/src/com/android/launcher3/debug/TestEventEmitter.java
@@ -34,7 +34,9 @@
         RESIZE_FRAME_SHOWING("RESIZE_FRAME_SHOWING"),
         WORKSPACE_FINISH_LOADING("WORKSPACE_FINISH_LOADING"),
         SPRING_LOADED_STATE_STARTED("SPRING_LOADED_STATE_STARTED"),
-        SPRING_LOADED_STATE_COMPLETED("SPRING_LOADED_STATE_COMPLETED");
+        SPRING_LOADED_STATE_COMPLETED("SPRING_LOADED_STATE_COMPLETED"),
+
+        LAUNCHER_STATE_COMPLETED("LAUNCHER_STATE_COMPLETED");
 
         TestEvent(String event) {
         }
diff --git a/src/com/android/launcher3/dot/FolderDotInfo.java b/src/com/android/launcher3/dot/FolderDotInfo.java
index 54800a0..cb91db7 100644
--- a/src/com/android/launcher3/dot/FolderDotInfo.java
+++ b/src/com/android/launcher3/dot/FolderDotInfo.java
@@ -30,6 +30,10 @@
 
     private int mNumNotifications;
 
+    public void reset() {
+        mNumNotifications = 0;
+    }
+
     public void addDotInfo(DotInfo dotToAdd) {
         if (dotToAdd == null) {
             return;
@@ -39,15 +43,6 @@
                 mNumNotifications, MIN_COUNT, DotInfo.MAX_COUNT);
     }
 
-    public void subtractDotInfo(DotInfo dotToSubtract) {
-        if (dotToSubtract == null) {
-            return;
-        }
-        mNumNotifications -= dotToSubtract.getNotificationKeys().size();
-        mNumNotifications = Utilities.boundToRange(
-                mNumNotifications, MIN_COUNT, DotInfo.MAX_COUNT);
-    }
-
     @Override
     public int getNotificationCount() {
         return mNumNotifications;
diff --git a/src/com/android/launcher3/dragndrop/DragController.java b/src/com/android/launcher3/dragndrop/DragController.java
index 613b430..415a2c6 100644
--- a/src/com/android/launcher3/dragndrop/DragController.java
+++ b/src/com/android/launcher3/dragndrop/DragController.java
@@ -16,6 +16,7 @@
 
 package com.android.launcher3.dragndrop;
 
+import static com.android.launcher3.Flags.removeAppsRefreshOnRightClick;
 import static com.android.launcher3.model.data.ItemInfoWithIcon.FLAG_NOT_PINNABLE;
 
 import android.graphics.Point;
@@ -521,17 +522,21 @@
 
         mDragObject.dragComplete = true;
         if (mIsInPreDrag) {
-            if (dropTarget != null) {
-                dropTarget.onDragExit(mDragObject);
+            if (removeAppsRefreshOnRightClick()) {
+                mDragObject.cancelled = true;
+            } else {
+                if (dropTarget != null) {
+                    dropTarget.onDragExit(mDragObject);
+                }
+                return;
             }
-            return;
         }
 
         // Drop onto the target.
         boolean accepted = false;
         if (dropTarget != null) {
             dropTarget.onDragExit(mDragObject);
-            if (dropTarget.acceptDrop(mDragObject)) {
+            if (!mIsInPreDrag && dropTarget.acceptDrop(mDragObject)) {
                 if (flingAnimation != null) {
                     flingAnimation.run();
                 } else {
@@ -539,9 +544,10 @@
                 }
                 accepted = true;
             }
+
+            final View dropTargetAsView = dropTarget.getDropView();
+            dispatchDropComplete(dropTargetAsView, accepted);
         }
-        final View dropTargetAsView = dropTarget instanceof View ? (View) dropTarget : null;
-        dispatchDropComplete(dropTargetAsView, accepted);
     }
 
     private DropTarget findDropTarget(final int x, final int y) {
diff --git a/src/com/android/launcher3/dragndrop/LauncherDragController.java b/src/com/android/launcher3/dragndrop/LauncherDragController.java
index 4aa3673..dd433c0 100644
--- a/src/com/android/launcher3/dragndrop/LauncherDragController.java
+++ b/src/com/android/launcher3/dragndrop/LauncherDragController.java
@@ -15,7 +15,10 @@
  */
 package com.android.launcher3.dragndrop;
 
+import static android.view.View.VISIBLE;
+
 import static com.android.launcher3.AbstractFloatingView.TYPE_DISCOVERY_BOUNCE;
+import static com.android.launcher3.Flags.removeAppsRefreshOnRightClick;
 import static com.android.launcher3.LauncherAnimUtils.SPRING_LOADED_EXIT_DELAY;
 import static com.android.launcher3.LauncherState.EDIT_MODE;
 import static com.android.launcher3.LauncherState.NORMAL;
@@ -25,6 +28,7 @@
 import android.graphics.Rect;
 import android.graphics.drawable.Drawable;
 import android.view.HapticFeedbackConstants;
+import android.view.MotionEvent;
 import android.view.View;
 
 import androidx.annotation.Nullable;
@@ -33,10 +37,13 @@
 import com.android.launcher3.AbstractFloatingView;
 import com.android.launcher3.DragSource;
 import com.android.launcher3.DropTarget;
+import com.android.launcher3.DropTarget.DragObject;
 import com.android.launcher3.Launcher;
 import com.android.launcher3.R;
 import com.android.launcher3.accessibility.DragViewStateAnnouncer;
+import com.android.launcher3.dragndrop.DragOptions.PreDragCondition;
 import com.android.launcher3.model.data.ItemInfo;
+import com.android.launcher3.util.TouchUtil;
 import com.android.launcher3.widget.util.WidgetDragScaleUtils;
 
 /**
@@ -47,6 +54,9 @@
     private static final boolean PROFILE_DRAWING_DURING_DRAG = false;
     private final FlingToDeleteHelper mFlingToDeleteHelper;
 
+    /** Whether or not the drag operation is triggered by mouse right click. */
+    private boolean mIsInMouseRightClick = false;
+
     public LauncherDragController(Launcher launcher) {
         super(launcher);
         mFlingToDeleteHelper = new FlingToDeleteHelper(launcher);
@@ -69,6 +79,28 @@
             android.os.Debug.startMethodTracing("Launcher");
         }
 
+        if (removeAppsRefreshOnRightClick() && mIsInMouseRightClick
+                && options.preDragCondition == null
+                && originalView instanceof View v) {
+            options.preDragCondition = new PreDragCondition() {
+
+                @Override
+                public boolean shouldStartDrag(double distanceDragged) {
+                    return false;
+                }
+
+                @Override
+                public void onPreDragStart(DragObject dragObject) {
+                    // Set it to visible so the text of FolderIcon would not flash (avoid it from
+                    // being invisible and then visible)
+                    v.setVisibility(VISIBLE);
+                }
+
+                @Override
+                public void onPreDragEnd(DragObject dragObject, boolean dragStarted) { }
+            };
+        }
+
         mActivity.hideKeyboard();
         AbstractFloatingView.closeOpenViews(mActivity, false, TYPE_DISCOVERY_BOUNCE);
 
@@ -191,7 +223,7 @@
 
     @Override
     protected void exitDrag() {
-        if (!mActivity.isInState(EDIT_MODE)) {
+        if (!mIsInPreDrag && !mActivity.isInState(EDIT_MODE)) {
             mActivity.getStateManager().goToState(NORMAL, SPRING_LOADED_EXIT_DELAY);
         }
     }
@@ -218,4 +250,13 @@
                 dropCoordinates);
         return mActivity.getWorkspace();
     }
+
+    /**
+     * Intercepts touch events from a drag source view.
+     */
+    @Override
+    public boolean onControllerInterceptTouchEvent(MotionEvent ev) {
+        mIsInMouseRightClick = TouchUtil.isMouseRightClickDownOrMove(ev);
+        return super.onControllerInterceptTouchEvent(ev);
+    }
 }
diff --git a/src/com/android/launcher3/folder/Folder.java b/src/com/android/launcher3/folder/Folder.java
index 2803256..967af05 100644
--- a/src/com/android/launcher3/folder/Folder.java
+++ b/src/com/android/launcher3/folder/Folder.java
@@ -19,9 +19,6 @@
 import static android.text.TextUtils.isEmpty;
 
 import static com.android.launcher3.LauncherAnimUtils.SPRING_LOADED_EXIT_DELAY;
-import static com.android.launcher3.LauncherSettings.Favorites.ITEM_TYPE_APPLICATION;
-import static com.android.launcher3.LauncherSettings.Favorites.ITEM_TYPE_APP_PAIR;
-import static com.android.launcher3.LauncherSettings.Favorites.ITEM_TYPE_DEEP_SHORTCUT;
 import static com.android.launcher3.LauncherState.EDIT_MODE;
 import static com.android.launcher3.LauncherState.NORMAL;
 import static com.android.launcher3.compat.AccessibilityManagerCompat.sendCustomAccessibilityEvent;
@@ -29,6 +26,7 @@
 import static com.android.launcher3.folder.FolderGridOrganizer.createFolderGridOrganizer;
 import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_FOLDER_LABEL_UPDATED;
 import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_ITEM_DROP_COMPLETED;
+import static com.android.launcher3.model.data.FolderInfo.willAcceptItemType;
 import static com.android.launcher3.testing.shared.TestProtocol.FOLDER_OPENED_MESSAGE;
 import static com.android.launcher3.util.window.RefreshRateTracker.getSingleFrameMs;
 
@@ -95,14 +93,12 @@
 import com.android.launcher3.logging.StatsLogManager;
 import com.android.launcher3.logging.StatsLogManager.StatsLogger;
 import com.android.launcher3.model.data.FolderInfo;
-import com.android.launcher3.model.data.FolderInfo.FolderListener;
 import com.android.launcher3.model.data.ItemInfo;
 import com.android.launcher3.model.data.WorkspaceItemFactory;
 import com.android.launcher3.model.data.WorkspaceItemInfo;
 import com.android.launcher3.pageindicators.PageIndicatorDots;
 import com.android.launcher3.util.Executors;
 import com.android.launcher3.util.LauncherBindableItemsContainer;
-import com.android.launcher3.util.LauncherBindableItemsContainer.ItemOperator;
 import com.android.launcher3.util.Thunk;
 import com.android.launcher3.views.ActivityContext;
 import com.android.launcher3.views.BaseDragLayer;
@@ -112,6 +108,7 @@
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Comparator;
 import java.util.List;
 import java.util.Objects;
@@ -123,7 +120,7 @@
  * Represents a set of icons chosen by the user or generated by the system.
  */
 public class Folder extends AbstractFloatingView implements ClipPathView, DragSource,
-        View.OnLongClickListener, DropTarget, FolderListener, TextView.OnEditorActionListener,
+        View.OnLongClickListener, DropTarget, TextView.OnEditorActionListener,
         View.OnFocusChangeListener, DragListener, ExtendedEditText.OnBackKeyListener,
         LauncherBindableItemsContainer {
     private static final String TAG = "Launcher.Folder";
@@ -180,15 +177,6 @@
         return o instanceof ItemInfo info && willAcceptItemType(info.itemType);
     }
 
-    /**
-     * Checks if {@code itemType} is a type that can be placed in folders.
-     */
-    public static boolean willAcceptItemType(int itemType) {
-        return itemType == ITEM_TYPE_APPLICATION
-                || itemType == ITEM_TYPE_DEEP_SHORTCUT
-                || itemType == ITEM_TYPE_APP_PAIR;
-    }
-
     private Alarm mReorderAlarm = new Alarm(Looper.getMainLooper());
     private Alarm mOnExitAlarm = new Alarm(Looper.getMainLooper());
     private Alarm mOnScrollHintAlarm = new Alarm(Looper.getMainLooper());
@@ -244,7 +232,10 @@
     private boolean mIsExternalDrag;
     private boolean mIsDragInProgress = false;
     private boolean mDeleteFolderOnDropCompleted = false;
+
     private boolean mSuppressFolderDeletion = false;
+    private boolean mSuppressContentUpdate = false;
+
     private boolean mItemAddedBackToSelfViaIcon = false;
     private boolean mIsEditingName = false;
 
@@ -386,9 +377,8 @@
 
         // We do not want to get events for the item being removed, as they will get handled
         // when the drop completes
-        try (SuppressInfoChanges s = new SuppressInfoChanges()) {
-            mInfo.remove(dragObject.dragInfo, true);
-        }
+        executeWithContentUpdateSuppressed(() -> removeFolderContent(true, dragObject.dragInfo));
+
         mIsDragInProgress = true;
         mItemAddedBackToSelfViaIcon = false;
     }
@@ -533,16 +523,7 @@
             lp.customPosition = true;
             setLayoutParams(lp);
         }
-        mItemsInvalidated = true;
-        mInfo.addListener(this);
-
-        if (!isEmpty(mInfo.title)) {
-            mFolderName.setText(mInfo.title);
-            mFolderName.setHint(null);
-        } else {
-            mFolderName.setText("");
-            mFolderName.setHint(R.string.folder_hint_text);
-        }
+        reapplyItemInfo();
         // In case any children didn't come across during loading, clean up the folder accordingly
         mFolderIcon.post(() -> {
             if (getItemCount() <= 1) {
@@ -551,6 +532,17 @@
         });
     }
 
+    public void reapplyItemInfo() {
+        mItemsInvalidated = true;
+
+        if (!isEmpty(mInfo.title)) {
+            mFolderName.setText(mInfo.title);
+            mFolderName.setHint(null);
+        } else {
+            mFolderName.setText("");
+            mFolderName.setHint(R.string.folder_hint_text);
+        }
+    }
 
     /**
      * Show suggested folder title in FolderEditText if the first suggestion is non-empty, push
@@ -681,7 +673,6 @@
         if (!shouldAnimateOpen(items)) {
             return;
         }
-
         Folder openFolder = getOpen(mActivityContext);
         closeOpenFolder(openFolder);
 
@@ -955,9 +946,7 @@
 
     @Override
     public boolean acceptDrop(DragObject d) {
-        final ItemInfo item = d.dragInfo;
-        final int itemType = item.itemType;
-        return Folder.willAcceptItemType(itemType);
+        return willAcceptItemType(d.dragInfo.itemType);
     }
 
     public void onDragEnter(DragObject d) {
@@ -1116,13 +1105,14 @@
             View icon = (mCurrentDragView != null && mCurrentDragView.getTag() == info)
                     ? mCurrentDragView : mContent.createNewView(info);
             ArrayList<View> views = getIconsInReadingOrder();
-            info.rank = Utilities.boundToRange(info.rank, 0, views.size());
-            views.add(info.rank, icon);
-            mContent.arrangeChildren(views);
-            mItemsInvalidated = true;
+            if (!views.contains(icon)) {
+                info.rank = Utilities.boundToRange(info.rank, 0, views.size());
+                views.add(info.rank, icon);
+                mContent.arrangeChildren(views);
+                mItemsInvalidated = true;
 
-            try (SuppressInfoChanges s = new SuppressInfoChanges()) {
-                mFolderIcon.onDrop(d, true /* itemReturnedOnFailedDrop */);
+                executeWithContentUpdateSuppressed(
+                        () -> mFolderIcon.onDrop(d, true /* itemReturnedOnFailedDrop */));
             }
         }
 
@@ -1416,9 +1406,7 @@
             rearrangeChildren();
 
             // Temporarily suppress the listener, as we did all the work already here.
-            try (SuppressInfoChanges s = new SuppressInfoChanges()) {
-                mInfo.add(si, mEmptyCellRank, false);
-            }
+            executeWithContentUpdateSuppressed(() -> addFolderContent(si, mEmptyCellRank, false));
 
             // We only need to update the locations if it doesn't get handled in
             // #onDropCompleted.
@@ -1464,37 +1452,66 @@
         }
     }
 
-    @Override
-    public void onAdd(ItemInfo item, int rank) {
-        FolderGridOrganizer verifier = createFolderGridOrganizer(
-                mActivityContext.getDeviceProfile()).setFolderInfo(mInfo);
-        verifier.updateRankAndPos(item, rank);
-        mLauncherDelegate.getModelWriter().addOrMoveItemInDatabase(item, mInfo.id, 0, item.cellX,
-                item.cellY);
-        updateItemLocationsInDatabaseBatch(false);
-
-        if (mContent.areViewsBound()) {
-            mContent.createAndAddViewForRank(item, rank);
-        }
-        mItemsInvalidated = true;
+    /** Add an app or shortcut */
+    public void addFolderContent(ItemInfo item) {
+        addFolderContent(item, mInfo.getContents().size(), true);
     }
 
-    @Override
-    public void onRemove(List<ItemInfo> items) {
-        mItemsInvalidated = true;
-        items.stream().map(this::getViewForInfo).forEach(mContent::removeItem);
-        if (mState == STATE_ANIMATING) {
-            mRearrangeOnClose = true;
-        } else {
-            rearrangeChildren();
+    /** Add an app or shortcut for a specified rank */
+    public void addFolderContent(ItemInfo item, int rank, boolean animate) {
+        if (!willAcceptItemType(item.itemType)) {
+            throw new RuntimeException("tried to add an illegal type into a folder");
         }
-        if (getItemCount() <= 1) {
-            if (mIsOpen) {
-                close(true);
-            } else {
-                replaceFolderWithFinalItem();
+
+        rank = Utilities.boundToRange(rank, 0, mInfo.getContents().size());
+        mInfo.getContents().add(rank, item);
+
+        if (!mSuppressContentUpdate) {
+            FolderGridOrganizer verifier = createFolderGridOrganizer(
+                    mActivityContext.getDeviceProfile()).setFolderInfo(mInfo);
+            verifier.updateRankAndPos(item, rank);
+            mLauncherDelegate.getModelWriter().addOrMoveItemInDatabase(item, mInfo.id, 0,
+                    item.cellX,
+                    item.cellY);
+            updateItemLocationsInDatabaseBatch(false);
+
+            if (mContent.areViewsBound()) {
+                mContent.createAndAddViewForRank(item, rank);
             }
+            mItemsInvalidated = true;
+            updateTextViewFocus();
         }
+
+        mLauncherDelegate.getModelWriter().notifyItemModified(mInfo);
+        mFolderIcon.onItemsChanged(animate);
+    }
+
+    /** Remove all matching app or shortcut. Does not change the DB. */
+    public void removeFolderContent(boolean animate, ItemInfo... items) {
+        List<ItemInfo> itemArray = Arrays.asList(items);
+        if (mInfo.getContents().removeAll(itemArray)) {
+            mLauncherDelegate.getModelWriter().notifyItemModified(mInfo);
+        }
+
+        if (!mSuppressContentUpdate) {
+            mItemsInvalidated = true;
+            itemArray.forEach(item -> mContent.removeItem(getViewForInfo(item)));
+            if (mState == STATE_ANIMATING) {
+                mRearrangeOnClose = true;
+            } else {
+                rearrangeChildren();
+            }
+            if (getItemCount() <= 1) {
+                if (mIsOpen) {
+                    close(true);
+                } else {
+                    replaceFolderWithFinalItem();
+                }
+            }
+            updateTextViewFocus();
+        }
+
+        mFolderIcon.onItemsChanged(animate);
     }
 
     @VisibleForTesting
@@ -1502,16 +1519,6 @@
         return mContent.iterateOverItems((info, view) -> info == item);
     }
 
-    @Override
-    public void onItemsChanged(boolean animate) {
-        updateTextViewFocus();
-    }
-
-    @Override
-    public void onTitleChanged(CharSequence title) {
-        mFolderName.setText(title);
-    }
-
     /**
      * Utility methods to iterate over items of the view
      */
@@ -1665,18 +1672,14 @@
         }
     };
 
-    /**
-     * Temporary resource held while we don't want to handle info changes
-     */
-    private class SuppressInfoChanges implements AutoCloseable {
-
-        SuppressInfoChanges() {
-            mInfo.removeListener(Folder.this);
-        }
-
-        @Override
-        public void close() {
-            mInfo.addListener(Folder.this);
+    /** Executes the task while suppressing the content update for the folder */
+    private void executeWithContentUpdateSuppressed(Runnable task) {
+        if (mSuppressContentUpdate) {
+            task.run();
+        } else {
+            mSuppressContentUpdate = true;
+            task.run();
+            mSuppressContentUpdate = false;
             updateTextViewFocus();
         }
     }
diff --git a/src/com/android/launcher3/folder/FolderIcon.java b/src/com/android/launcher3/folder/FolderIcon.java
index 0ed8787..1cd9bcc 100644
--- a/src/com/android/launcher3/folder/FolderIcon.java
+++ b/src/com/android/launcher3/folder/FolderIcon.java
@@ -23,6 +23,7 @@
 import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_FOLDER_AUTO_LABELED;
 import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_FOLDER_AUTO_LABELING_SKIPPED_EMPTY_PRIMARY;
 import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_FOLDER_AUTO_LABELING_SKIPPED_EMPTY_SUGGESTIONS;
+import static com.android.launcher3.model.data.FolderInfo.willAcceptItemType;
 
 import android.animation.Animator;
 import android.animation.AnimatorListenerAdapter;
@@ -73,7 +74,6 @@
 import com.android.launcher3.logging.StatsLogManager;
 import com.android.launcher3.model.data.AppPairInfo;
 import com.android.launcher3.model.data.FolderInfo;
-import com.android.launcher3.model.data.FolderInfo.FolderListener;
 import com.android.launcher3.model.data.FolderInfo.LabelState;
 import com.android.launcher3.model.data.ItemInfo;
 import com.android.launcher3.model.data.WorkspaceItemFactory;
@@ -92,7 +92,7 @@
 /**
  * An icon that can appear on in the workspace representing an {@link Folder}.
  */
-public class FolderIcon extends FrameLayout implements FolderListener, FloatingIconViewCompanion,
+public class FolderIcon extends FrameLayout implements FloatingIconViewCompanion,
         DraggableView, Reorderable {
 
     private final MultiTranslateDelegate mTranslateDelegate = new MultiTranslateDelegate(this);
@@ -127,7 +127,7 @@
 
     private boolean mForceHideDot;
     @ViewDebug.ExportedProperty(category = "launcher", deepExport = true)
-    private FolderDotInfo mDotInfo = new FolderDotInfo();
+    private final FolderDotInfo mDotInfo = new FolderDotInfo();
     private DotRenderer mDotRenderer;
     @ViewDebug.ExportedProperty(category = "launcher", deepExport = true)
     private DotRenderer.DrawParams mDotParams;
@@ -178,7 +178,6 @@
         folder.bind(folderInfo);
 
         icon.setFolder(folder);
-        folderInfo.addListener(icon);
         return icon;
     }
 
@@ -217,13 +216,7 @@
         icon.mDotRenderer = grid.mDotRendererWorkSpace;
 
         icon.setContentDescription(icon.getAccessiblityTitle(folderInfo.title));
-
-        // Keep the notification dot up to date with the sum of all the content's dots.
-        FolderDotInfo folderDotInfo = new FolderDotInfo();
-        for (ItemInfo si : folderInfo.getContents()) {
-            folderDotInfo.addDotInfo(activity.getDotInfoForItem(si));
-        }
-        icon.setDotInfo(folderDotInfo);
+        icon.updateDotInfo();
 
         icon.setAccessibilityDelegate(activity.getAccessibilityDelegate());
 
@@ -264,22 +257,13 @@
     }
 
     private boolean willAcceptItem(ItemInfo item) {
-        final int itemType = item.itemType;
-        return (Folder.willAcceptItemType(itemType) && item != mInfo && !mFolder.isOpen());
+        return (willAcceptItemType(item.itemType) && item != mInfo && !mFolder.isOpen());
     }
 
     public boolean acceptDrop(ItemInfo dragInfo) {
         return !mFolder.isDestroyed() && willAcceptItem(dragInfo);
     }
 
-    public void addItem(ItemInfo item) {
-        mInfo.add(item, true);
-    }
-
-    public void removeItem(ItemInfo item, boolean animate) {
-        mInfo.remove(item, animate);
-    }
-
     public void onDragEnter(ItemInfo dragInfo) {
         if (mFolder.isDestroyed() || !willAcceptItem(dragInfo)) return;
         CellLayoutLayoutParams lp = (CellLayoutLayoutParams) getLayoutParams();
@@ -308,9 +292,8 @@
     public void performCreateAnimation(final ItemInfo destInfo, final View destView,
             final ItemInfo srcInfo, final DragObject d, Rect dstRect,
             float scaleRelativeToDragLayer) {
-        final DragView srcView = d.dragView;
         prepareCreateAnimation(destView);
-        addItem(destInfo);
+        getFolder().addFolderContent(destInfo);
         // This will animate the first item from it's position as an icon into its
         // position as the first item in the preview
         mPreviewItemManager.createFirstItemAnimation(false /* reverse */, null)
@@ -364,7 +347,7 @@
             boolean itemAdded = false;
             if (itemReturnedOnFailedDrop || index >= MAX_NUM_ITEMS_IN_PREVIEW) {
                 List<ItemInfo> oldPreviewItems = new ArrayList<>(mCurrentPreviewItems);
-                mInfo.add(item, index, false);
+                getFolder().addFolderContent(item, index, false);
                 mCurrentPreviewItems.clear();
                 mCurrentPreviewItems.addAll(getPreviewItemsOnPage(0));
 
@@ -380,12 +363,12 @@
                     mPreviewItemManager.onDrop(oldPreviewItems, mCurrentPreviewItems, item);
                     itemAdded = true;
                 } else {
-                    removeItem(item, false);
+                    getFolder().removeFolderContent(false, item);
                 }
             }
 
             if (!itemAdded) {
-                mInfo.add(item, index, true);
+                getFolder().addFolderContent(item, index, true);
             }
 
             int[] center = new int[2];
@@ -431,7 +414,7 @@
                 }, DROP_IN_ANIMATION_DURATION);
             });
         } else {
-            addItem(item);
+            getFolder().addFolderContent(item);
         }
     }
 
@@ -500,9 +483,23 @@
         );
     }
 
-    public void setDotInfo(FolderDotInfo dotInfo) {
-        updateDotScale(mDotInfo.hasDot(), dotInfo.hasDot());
-        mDotInfo = dotInfo;
+    /** Keep the notification dot up to date with the sum of all the content's dots. */
+    public void updateDotInfo() {
+        boolean hadDot = mDotInfo.hasDot();
+        mDotInfo.reset();
+        for (ItemInfo si : mInfo.getContents()) {
+            mDotInfo.addDotInfo(mActivity.getDotInfoForItem(si));
+        }
+        boolean isDotted = mDotInfo.hasDot();
+        float newDotScale = isDotted ? 1f : 0f;
+        // Animate when a dot is first added or when it is removed.
+        if ((hadDot ^ isDotted) && isShown()) {
+            animateDotScale(newDotScale);
+        } else {
+            cancelDotScaleAnim();
+            mDotScale = newDotScale;
+            invalidate();
+        }
     }
 
     public ClippedFolderIconLayoutRule getLayoutRule() {
@@ -523,22 +520,6 @@
         }
     }
 
-    /**
-     * Sets mDotScale to 1 or 0, animating if wasDotted or isDotted is false
-     * (the dot is being added or removed).
-     */
-    private void updateDotScale(boolean wasDotted, boolean isDotted) {
-        float newDotScale = isDotted ? 1f : 0f;
-        // Animate when a dot is first added or when it is removed.
-        if ((wasDotted ^ isDotted) && isShown()) {
-            animateDotScale(newDotScale);
-        } else {
-            cancelDotScaleAnim();
-            mDotScale = newDotScale;
-            invalidate();
-        }
-    }
-
     private void cancelDotScaleAnim() {
         if (mDotScaleAnim != null) {
             mDotScaleAnim.cancel();
@@ -682,13 +663,6 @@
         return mPreviewItemManager.verifyDrawable(who) || super.verifyDrawable(who);
     }
 
-    @Override
-    public void onItemsChanged(boolean animate) {
-        updatePreviewItems(animate);
-        invalidate();
-        requestLayout();
-    }
-
     private void updatePreviewItems(boolean animate) {
         mPreviewItemManager.updatePreviewItems(animate);
         mCurrentPreviewItems.clear();
@@ -702,31 +676,15 @@
         mPreviewItemManager.updatePreviewItems(itemCheck);
     }
 
-    @Override
-    public void onAdd(ItemInfo item, int rank) {
+    public void onItemsChanged(boolean animate) {
         updatePreviewItems(false);
-        boolean wasDotted = mDotInfo.hasDot();
-        mDotInfo.addDotInfo(mActivity.getDotInfoForItem(item));
-        boolean isDotted = mDotInfo.hasDot();
-        updateDotScale(wasDotted, isDotted);
+        updateDotInfo();
         setContentDescription(getAccessiblityTitle(mInfo.title));
+        updatePreviewItems(animate);
         invalidate();
         requestLayout();
     }
 
-    @Override
-    public void onRemove(List<ItemInfo> items) {
-        updatePreviewItems(false);
-        boolean wasDotted = mDotInfo.hasDot();
-        items.stream().map(mActivity::getDotInfoForItem).forEach(mDotInfo::subtractDotInfo);
-        boolean isDotted = mDotInfo.hasDot();
-        updateDotScale(wasDotted, isDotted);
-        setContentDescription(getAccessiblityTitle(mInfo.title));
-        invalidate();
-        requestLayout();
-    }
-
-    @Override
     public void onTitleChanged(CharSequence title) {
         mFolderName.setText(title);
         setContentDescription(getAccessiblityTitle(title));
@@ -762,11 +720,6 @@
         mLongPressHelper.cancelLongPress();
     }
 
-    public void removeListeners() {
-        mInfo.removeListener(this);
-        mInfo.removeListener(mFolder);
-    }
-
     private boolean isInHotseat() {
         return mInfo.container == LauncherSettings.Favorites.CONTAINER_HOTSEAT;
     }
diff --git a/src/com/android/launcher3/folder/FolderPagedView.java b/src/com/android/launcher3/folder/FolderPagedView.java
index bebe1a4..0963421 100644
--- a/src/com/android/launcher3/folder/FolderPagedView.java
+++ b/src/com/android/launcher3/folder/FolderPagedView.java
@@ -47,6 +47,7 @@
 import com.android.launcher3.model.data.AppPairInfo;
 import com.android.launcher3.model.data.ItemInfo;
 import com.android.launcher3.model.data.WorkspaceItemInfo;
+import com.android.launcher3.pageindicators.Direction;
 import com.android.launcher3.pageindicators.PageIndicatorDots;
 import com.android.launcher3.util.LauncherBindableItemsContainer.ItemOperator;
 import com.android.launcher3.util.Thunk;
@@ -129,6 +130,8 @@
     public void setFolder(Folder folder) {
         mFolder = folder;
         mPageIndicator = folder.findViewById(R.id.folder_page_indicator);
+        mPageIndicator.setArrowClickListener(direction -> snapToPageImmediately(
+                (Direction.END == direction) ? mCurrentPage + 1 : mCurrentPage - 1));
         initParentViews(folder);
     }
 
diff --git a/src/com/android/launcher3/graphics/GridCustomizationsProxy.java b/src/com/android/launcher3/graphics/GridCustomizationsProxy.java
index 70b9f46..b40e099 100644
--- a/src/com/android/launcher3/graphics/GridCustomizationsProxy.java
+++ b/src/com/android/launcher3/graphics/GridCustomizationsProxy.java
@@ -113,6 +113,7 @@
     private static final String KEY_SHAPE_OPTIONS = "/shape_options";
     // default_grid is for setting grid and shape to system settings
     private static final String KEY_DEFAULT_GRID = "/default_grid";
+    private static final String SET_SHAPE = "/shape";
 
     private static final String METHOD_GET_PREVIEW = "get_preview";
 
@@ -130,6 +131,7 @@
     private static final int MESSAGE_ID_UPDATE_SHAPE = 2586;
     private static final int MESSAGE_ID_UPDATE_GRID = 7414;
     private static final int MESSAGE_ID_UPDATE_COLOR = 856;
+    private static final int MESSAGE_ID_UPDATE_ICON_THEMED = 311;
 
     // Set of all active previews used to track duplicate memory allocations
     private final Set<PreviewLifecycleObserver> mActivePreviews =
@@ -141,7 +143,7 @@
     private final InvariantDeviceProfile mIdp;
 
     @Inject
-    GridCustomizationsProxy(
+    protected GridCustomizationsProxy(
             @ApplicationContext Context context,
             ThemeManager themeManager,
             LauncherPrefs prefs,
@@ -264,6 +266,12 @@
                 mContext.getContentResolver().notifyChange(uri, null);
                 return 1;
             }
+            case SET_SHAPE:
+                if (Flags.newCustomizationPickerUi()) {
+                    mPrefs.put(PREF_ICON_SHAPE,
+                            requireNonNullElse(values.getAsString(KEY_SHAPE_KEY), ""));
+                }
+                return 1;
             case ICON_THEMED:
             case SET_ICON_THEMED: {
                 mThemeManager.setMonoThemeEnabled(values.getAsBoolean(BOOLEAN_VALUE));
@@ -384,6 +392,12 @@
                         renderer.previewColor(message.getData());
                     }
                     break;
+                case MESSAGE_ID_UPDATE_ICON_THEMED:
+                    if (Flags.newCustomizationPickerUi()) {
+                        Boolean iconThemed = message.getData().getBoolean(BOOLEAN_VALUE);
+                        // TODO Update icon themed in the preview
+                    }
+                    break;
                 default:
                     // Unknown command, destroy lifecycle
                     Log.d(TAG, "Unknown preview command: " + message.what + ", destroying preview");
diff --git a/src/com/android/launcher3/graphics/LauncherPreviewRenderer.java b/src/com/android/launcher3/graphics/LauncherPreviewRenderer.java
index b80238c..e4e4b90 100644
--- a/src/com/android/launcher3/graphics/LauncherPreviewRenderer.java
+++ b/src/com/android/launcher3/graphics/LauncherPreviewRenderer.java
@@ -80,8 +80,10 @@
 import com.android.launcher3.dagger.LauncherAppModule;
 import com.android.launcher3.dagger.LauncherAppSingleton;
 import com.android.launcher3.folder.FolderIcon;
+import com.android.launcher3.model.BaseLauncherBinder.BaseLauncherBinderFactory;
 import com.android.launcher3.model.BgDataModel;
 import com.android.launcher3.model.BgDataModel.FixedContainerItems;
+import com.android.launcher3.model.LoaderTask.LoaderTaskFactory;
 import com.android.launcher3.model.data.AppPairInfo;
 import com.android.launcher3.model.data.CollectionInfo;
 import com.android.launcher3.model.data.FolderInfo;
@@ -605,6 +607,10 @@
     @Component(modules = LauncherAppModule.class)
     public interface PreviewAppComponent extends LauncherAppComponent {
 
+        LoaderTaskFactory getLoaderTaskFactory();
+        BaseLauncherBinderFactory getBaseLauncherBinderFactory();
+        BgDataModel getDataModel();
+
         /** Builder for NexusLauncherAppComponent. */
         @Component.Builder
         interface Builder extends LauncherAppComponent.Builder {
diff --git a/src/com/android/launcher3/graphics/PreviewSurfaceRenderer.java b/src/com/android/launcher3/graphics/PreviewSurfaceRenderer.java
index d425f03..457d12e 100644
--- a/src/com/android/launcher3/graphics/PreviewSurfaceRenderer.java
+++ b/src/com/android/launcher3/graphics/PreviewSurfaceRenderer.java
@@ -21,7 +21,6 @@
 import static android.view.Display.DEFAULT_DISPLAY;
 
 import static com.android.launcher3.LauncherPrefs.GRID_NAME;
-import static com.android.launcher3.LauncherSettings.Favorites.TABLE_NAME;
 import static com.android.launcher3.graphics.ThemeManager.PREF_ICON_SHAPE;
 import static com.android.launcher3.util.Executors.MAIN_EXECUTOR;
 import static com.android.launcher3.util.Executors.MODEL_EXECUTOR;
@@ -58,19 +57,21 @@
 import com.android.launcher3.LauncherPrefs;
 import com.android.launcher3.LauncherSettings;
 import com.android.launcher3.Workspace;
+import com.android.launcher3.dagger.LauncherComponentProvider;
+import com.android.launcher3.graphics.LauncherPreviewRenderer.PreviewAppComponent;
 import com.android.launcher3.graphics.LauncherPreviewRenderer.PreviewContext;
-import com.android.launcher3.model.BaseLauncherBinder;
 import com.android.launcher3.model.BgDataModel;
 import com.android.launcher3.model.BgDataModel.Callbacks;
 import com.android.launcher3.model.LoaderTask;
 import com.android.launcher3.model.ModelDbController;
+import com.android.launcher3.model.UserManagerState;
 import com.android.launcher3.util.ComponentKey;
 import com.android.launcher3.util.RunnableList;
 import com.android.launcher3.util.Themes;
 import com.android.launcher3.widget.LocalColorExtractor;
 import com.android.systemui.shared.Flags;
 
-import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.TimeUnit;
 
@@ -177,7 +178,7 @@
 
         ModelDbController mainController =
                 LauncherAppState.getInstance(mContext).getModel().getModelDbController();
-        try (Cursor c = mainController.query(TABLE_NAME,
+        try (Cursor c = mainController.query(
                 new String[] {
                         LauncherSettings.Favorites.APPWIDGET_ID,
                         LauncherSettings.Favorites.SPANX,
@@ -338,38 +339,32 @@
             // Start the migration
             PreviewContext previewContext =
                     new PreviewContext(inflationContext, mGridName, mShapeKey);
+            PreviewAppComponent appComponent =
+                    (PreviewAppComponent) LauncherComponentProvider.get(previewContext);
 
-            BgDataModel bgModel = new BgDataModel();
-            new LoaderTask(
-                    LauncherAppState.getInstance(previewContext),
-                    /* bgAllAppsList= */ null,
-                    bgModel,
-                    LauncherAppState.getInstance(previewContext).getModel().getModelDelegate(),
-                    new BaseLauncherBinder(LauncherAppState.getInstance(previewContext), bgModel,
-                            /* bgAllAppsList= */ null, new Callbacks[0])) {
+            LoaderTask task = appComponent.getLoaderTaskFactory().newLoaderTask(
+                    appComponent.getBaseLauncherBinderFactory().createBinder(new Callbacks[0]),
+                    new UserManagerState());
 
-                @Override
-                public void run() {
-                    InvariantDeviceProfile idp = LauncherAppState.getIDP(previewContext);
-                    DeviceProfile deviceProfile = idp.getDeviceProfile(previewContext);
-                    String query =
-                            LauncherSettings.Favorites.SCREEN + " = " + Workspace.FIRST_SCREEN_ID
-                                    + " or " + LauncherSettings.Favorites.CONTAINER + " = "
-                                    + LauncherSettings.Favorites.CONTAINER_HOTSEAT;
-                    if (deviceProfile.isTwoPanels) {
-                        query += " or " + LauncherSettings.Favorites.SCREEN + " = "
-                                + Workspace.SECOND_SCREEN_ID;
-                    }
-                    loadWorkspace(new ArrayList<>(), query, null, null);
+            InvariantDeviceProfile idp = appComponent.getIDP();
+            DeviceProfile deviceProfile = idp.getDeviceProfile(previewContext);
+            String query =
+                    LauncherSettings.Favorites.SCREEN + " = " + Workspace.FIRST_SCREEN_ID
+                            + " or " + LauncherSettings.Favorites.CONTAINER + " = "
+                            + LauncherSettings.Favorites.CONTAINER_HOTSEAT;
+            if (deviceProfile.isTwoPanels) {
+                query += " or " + LauncherSettings.Favorites.SCREEN + " = "
+                        + Workspace.SECOND_SCREEN_ID;
+            }
 
-                    final SparseArray<Size> spanInfo = getLoadedLauncherWidgetInfo();
-                    MAIN_EXECUTOR.execute(() -> {
-                        renderView(previewContext, mBgDataModel, mWidgetProvidersMap, spanInfo,
-                                idp);
-                        mLifeCycleTracker.add(previewContext::onDestroy);
-                    });
-                }
-            }.run();
+            Map<ComponentKey, AppWidgetProviderInfo> widgetProviderInfoMap = new HashMap<>();
+            task.loadWorkspaceForPreview(query, widgetProviderInfoMap);
+            final SparseArray<Size> spanInfo = getLoadedLauncherWidgetInfo();
+            MAIN_EXECUTOR.execute(() -> {
+                renderView(previewContext, appComponent.getDataModel(), widgetProviderInfoMap,
+                        spanInfo, idp);
+                mLifeCycleTracker.add(previewContext::onDestroy);
+            });
         } else {
             LauncherAppState.getInstance(inflationContext).getModel().loadAsync(dataModel -> {
                 if (dataModel != null) {
@@ -420,7 +415,6 @@
             view.setTranslationY((mHeight - scale * view.getHeight()) / 2);
         }
 
-
         if (!Flags.newCustomizationPickerUi()) {
             view.setAlpha(mSkipAnimations ? 1 : 0);
             view.animate().alpha(1)
@@ -477,5 +471,4 @@
             MAIN_EXECUTOR.execute(mLifecycleTracker::executeAllAndDestroy);
         }
     }
-
 }
diff --git a/src/com/android/launcher3/graphics/ShapeDelegate.kt b/src/com/android/launcher3/graphics/ShapeDelegate.kt
index 7c04292..01bfe30 100644
--- a/src/com/android/launcher3/graphics/ShapeDelegate.kt
+++ b/src/com/android/launcher3/graphics/ShapeDelegate.kt
@@ -18,6 +18,7 @@
 import android.animation.Animator
 import android.animation.AnimatorListenerAdapter
 import android.animation.ValueAnimator
+import android.animation.ValueAnimator.AnimatorUpdateListener
 import android.graphics.Canvas
 import android.graphics.Color
 import android.graphics.Matrix
@@ -41,7 +42,6 @@
 import androidx.graphics.shapes.rectangle
 import androidx.graphics.shapes.toPath
 import androidx.graphics.shapes.transformed
-import com.android.launcher3.anim.RoundedRectRevealOutlineProvider
 import com.android.launcher3.icons.GraphicsUtils
 import com.android.launcher3.views.ClipPathView
 
@@ -127,16 +127,20 @@
             endRadius: Float,
             isReversed: Boolean,
         ): ValueAnimator where T : View, T : ClipPathView {
-            return object :
-                    RoundedRectRevealOutlineProvider(
-                        (startRect.width() / 2f) * radiusRatio,
-                        endRadius,
-                        startRect,
-                        endRect,
-                    ) {
-                    override fun shouldRemoveElevationDuringAnimation() = true
-                }
-                .createRevealAnimator(target, isReversed)
+            val startRadius = (startRect.width() / 2f) * radiusRatio
+            return ClipAnimBuilder(target) { progress, path ->
+                val radius = (1 - progress) * startRadius + progress * endRadius
+                path.addRoundRect(
+                    (1 - progress) * startRect.left + progress * endRect.left,
+                    (1 - progress) * startRect.top + progress * endRect.top,
+                    (1 - progress) * startRect.right + progress * endRect.right,
+                    (1 - progress) * startRect.bottom + progress * endRect.bottom,
+                    radius,
+                    radius,
+                    Path.Direction.CW,
+                )
+            }
+                .toAnim(isReversed)
         }
 
         override fun equals(other: Any?) =
@@ -220,40 +224,46 @@
                         ),
                 )
 
-            val va =
-                if (isReversed) ValueAnimator.ofFloat(1f, 0f) else ValueAnimator.ofFloat(0f, 1f)
-            va.addListener(
-                object : AnimatorListenerAdapter() {
-                    private var oldOutlineProvider: ViewOutlineProvider? = null
-
-                    override fun onAnimationStart(animation: Animator) {
-                        target.apply {
-                            oldOutlineProvider = outlineProvider
-                            outlineProvider = null
-                            translationZ = -target.elevation
-                        }
-                    }
-
-                    override fun onAnimationEnd(animation: Animator) {
-                        target.apply {
-                            translationZ = 0f
-                            setClipPath(null)
-                            outlineProvider = oldOutlineProvider
-                        }
-                    }
-                }
-            )
-
-            val path = Path()
-            va.addUpdateListener { anim: ValueAnimator ->
-                path.reset()
-                morph.toPath(anim.animatedValue as Float, path)
-                target.setClipPath(path)
-            }
-            return va
+            return ClipAnimBuilder(target, morph::toPath).toAnim(isReversed)
         }
     }
 
+    private class ClipAnimBuilder<T>(val target: T, val pathProvider: (Float, Path) -> Unit) :
+        AnimatorListenerAdapter(), AnimatorUpdateListener where T : View, T : ClipPathView {
+
+        private var oldOutlineProvider: ViewOutlineProvider? = null
+        val path = Path()
+
+        override fun onAnimationStart(animation: Animator) {
+            target.apply {
+                oldOutlineProvider = outlineProvider
+                outlineProvider = null
+                translationZ = -target.elevation
+            }
+        }
+
+        override fun onAnimationEnd(animation: Animator) {
+            target.apply {
+                translationZ = 0f
+                setClipPath(null)
+                outlineProvider = oldOutlineProvider
+            }
+        }
+
+        override fun onAnimationUpdate(anim: ValueAnimator) {
+            path.reset()
+            pathProvider.invoke(anim.animatedValue as Float, path)
+            target.setClipPath(path)
+        }
+
+        fun toAnim(isReversed: Boolean) =
+            (if (isReversed) ValueAnimator.ofFloat(1f, 0f) else ValueAnimator.ofFloat(0f, 1f))
+                .also {
+                    it.addListener(this)
+                    it.addUpdateListener(this)
+                }
+    }
+
     companion object {
 
         const val TAG = "IconShape"
diff --git a/src/com/android/launcher3/logging/StatsLogManager.java b/src/com/android/launcher3/logging/StatsLogManager.java
index 74d5098..44d2e26 100644
--- a/src/com/android/launcher3/logging/StatsLogManager.java
+++ b/src/com/android/launcher3/logging/StatsLogManager.java
@@ -166,6 +166,9 @@
         @UiEvent(doc = "User tapped or long pressed on settings icon inside launcher settings.")
         LAUNCHER_SETTINGS_BUTTON_TAP_OR_LONGPRESS(463),
 
+        @UiEvent(doc = "User tapped or long pressed on apps icon inside launcher settings.")
+        LAUNCHER_ALL_APPS_TAP_OR_LONGPRESS(2204),
+
         @UiEvent(doc = "User tapped or long pressed on widget tray icon inside launcher settings.")
         LAUNCHER_WIDGETSTRAY_BUTTON_TAP_OR_LONGPRESS(464),
 
@@ -880,6 +883,13 @@
 
         @UiEvent(doc = "Work utility view shrink animation ended")
         LAUNCHER_WORK_UTILITY_VIEW_SHRINK_ANIMATION_END(2078),
+
+        @UiEvent(doc = "Standard grid migration occurred")
+        LAUNCHER_STANDARD_GRID_MIGRATION(2200),
+
+        @UiEvent(doc = "Row shift grid migration occurred")
+        LAUNCHER_ROW_SHIFT_GRID_MIGRATION(2201),
+
         // ADD MORE
         ;
 
diff --git a/src/com/android/launcher3/model/AddWorkspaceItemsTask.java b/src/com/android/launcher3/model/AddWorkspaceItemsTask.java
index ddbbdc7..dfba4bb 100644
--- a/src/com/android/launcher3/model/AddWorkspaceItemsTask.java
+++ b/src/com/android/launcher3/model/AddWorkspaceItemsTask.java
@@ -66,13 +66,6 @@
 
     /**
      * @param itemList items to add on the workspace
-     */
-    public AddWorkspaceItemsTask(@NonNull final List<Pair<ItemInfo, Object>> itemList) {
-        this(itemList, new WorkspaceItemSpaceFinder());
-    }
-
-    /**
-     * @param itemList items to add on the workspace
      * @param itemSpaceFinder inject WorkspaceItemSpaceFinder dependency for testing
      */
     public AddWorkspaceItemsTask(@NonNull final List<Pair<ItemInfo, Object>> itemList,
@@ -91,7 +84,7 @@
 
         final ArrayList<ItemInfo> addedItemsFinal = new ArrayList<>();
         final IntArray addedWorkspaceScreensFinal = new IntArray();
-        final Context context = taskController.getApp().getContext();
+        final Context context = taskController.getContext();
 
         synchronized (dataModel) {
             IntArray workspaceScreens = dataModel.collectWorkspaceScreens();
@@ -133,7 +126,7 @@
 
             for (ItemInfo item : filteredItems) {
                 // Find appropriate space for the item.
-                int[] coords = mItemSpaceFinder.findSpaceForItem(taskController.getApp(), dataModel,
+                int[] coords = mItemSpaceFinder.findSpaceForItem(
                         workspaceScreens, addedWorkspaceScreensFinal, item.spanX, item.spanY);
                 int screenId = coords[0];
 
@@ -192,7 +185,7 @@
                             continue;
                         }
 
-                        IconCache cache = taskController.getApp().getIconCache();
+                        IconCache cache = taskController.getIconCache();
                         WorkspaceItemInfo wii = (WorkspaceItemInfo) itemInfo;
                         wii.title = "";
                         wii.bitmap = cache.getDefaultIcon(item.user);
diff --git a/src/com/android/launcher3/model/AllAppsList.java b/src/com/android/launcher3/model/AllAppsList.java
index 98f9afd..2311239 100644
--- a/src/com/android/launcher3/model/AllAppsList.java
+++ b/src/com/android/launcher3/model/AllAppsList.java
@@ -34,6 +34,7 @@
 
 import com.android.launcher3.AppFilter;
 import com.android.launcher3.compat.AlphabeticIndexCompat;
+import com.android.launcher3.dagger.LauncherAppSingleton;
 import com.android.launcher3.icons.IconCache;
 import com.android.launcher3.model.BgDataModel.Callbacks;
 import com.android.launcher3.model.data.AppInfo;
@@ -53,11 +54,13 @@
 import java.util.function.Consumer;
 import java.util.function.Predicate;
 
+import javax.inject.Inject;
+
 
 /**
  * Stores the list of all applications for the all apps view.
  */
-@SuppressWarnings("NewApi")
+@LauncherAppSingleton
 public class AllAppsList {
 
     private static final String TAG = "AllAppsList";
@@ -70,10 +73,10 @@
     public final ArrayList<AppInfo> data = new ArrayList<>(DEFAULT_APPLICATIONS_NUMBER);
 
     @NonNull
-    private IconCache mIconCache;
+    private final IconCache mIconCache;
 
     @NonNull
-    private AppFilter mAppFilter;
+    private final AppFilter mAppFilter;
 
     private boolean mDataChanged = false;
     private Consumer<AppInfo> mRemoveListener = NO_OP_CONSUMER;
@@ -92,6 +95,7 @@
     /**
      * Boring constructor.
      */
+    @Inject
     public AllAppsList(IconCache iconCache, AppFilter appFilter) {
         mIconCache = iconCache;
         mAppFilter = appFilter;
diff --git a/src/com/android/launcher3/model/BaseLauncherBinder.java b/src/com/android/launcher3/model/BaseLauncherBinder.java
index 262bf67..c4bbae4 100644
--- a/src/com/android/launcher3/model/BaseLauncherBinder.java
+++ b/src/com/android/launcher3/model/BaseLauncherBinder.java
@@ -26,6 +26,7 @@
 import static com.android.launcher3.util.Executors.MAIN_EXECUTOR;
 import static com.android.launcher3.util.Executors.MODEL_EXECUTOR;
 
+import android.content.Context;
 import android.os.Trace;
 import android.util.Log;
 import android.util.Pair;
@@ -34,11 +35,12 @@
 import androidx.annotation.NonNull;
 
 import com.android.launcher3.InvariantDeviceProfile;
-import com.android.launcher3.LauncherAppState;
+import com.android.launcher3.LauncherModel;
 import com.android.launcher3.LauncherModel.CallbackTask;
 import com.android.launcher3.LauncherSettings;
 import com.android.launcher3.celllayout.CellPosMapper;
 import com.android.launcher3.config.FeatureFlags;
+import com.android.launcher3.dagger.ApplicationContext;
 import com.android.launcher3.model.BgDataModel.Callbacks;
 import com.android.launcher3.model.BgDataModel.FixedContainerItems;
 import com.android.launcher3.model.data.AppInfo;
@@ -55,6 +57,10 @@
 import com.android.launcher3.widget.model.WidgetsListBaseEntriesBuilder;
 import com.android.launcher3.widget.model.WidgetsListBaseEntry;
 
+import dagger.assisted.Assisted;
+import dagger.assisted.AssistedFactory;
+import dagger.assisted.AssistedInject;
+
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
@@ -76,7 +82,9 @@
 
     protected final LooperExecutor mUiExecutor;
 
-    protected final LauncherAppState mApp;
+    private final Context mContext;
+    private final InvariantDeviceProfile mIDP;
+    private final LauncherModel mModel;
     protected final BgDataModel mBgDataModel;
     private final AllAppsList mBgAllAppsList;
 
@@ -84,10 +92,18 @@
 
     private int mMyBindingId;
 
-    public BaseLauncherBinder(LauncherAppState app, BgDataModel dataModel,
-            AllAppsList allAppsList, Callbacks[] callbacksList) {
+    @AssistedInject
+    public BaseLauncherBinder(
+            @ApplicationContext Context context,
+            InvariantDeviceProfile idp,
+            LauncherModel model,
+            BgDataModel dataModel,
+            AllAppsList allAppsList,
+            @Assisted Callbacks[] callbacksList) {
         mUiExecutor = MAIN_EXECUTOR;
-        mApp = app;
+        mContext = context;
+        mIDP = idp;
+        mModel = model;
         mBgDataModel = dataModel;
         mBgAllAppsList = allAppsList;
         mCallbacksList = callbacksList;
@@ -110,15 +126,14 @@
                 mBgDataModel.extraItems.forEach(extraItems::add);
                 if (incrementBindId) {
                     mBgDataModel.lastBindId++;
-                    mBgDataModel.lastLoadId = mApp.getModel().getLastLoadId();
+                    mBgDataModel.lastLoadId = mModel.getLastLoadId();
                 }
                 mMyBindingId = mBgDataModel.lastBindId;
                 workspaceItemCount = mBgDataModel.itemsIdMap.size();
             }
 
             for (Callbacks cb : mCallbacksList) {
-                new UnifiedWorkspaceBinder(cb, mUiExecutor, mApp, mBgDataModel, mMyBindingId,
-                        itemsIdMap, extraItems, orderedScreenIds)
+                new UnifiedWorkspaceBinder(cb, itemsIdMap, extraItems, orderedScreenIds)
                         .bind(isBindSync, workspaceItemCount);
             }
         } finally {
@@ -162,9 +177,8 @@
         if (!WIDGETS_ENABLED) {
             return;
         }
-        List<WidgetsListBaseEntry> widgets = new WidgetsListBaseEntriesBuilder(mApp.getContext())
+        List<WidgetsListBaseEntry> widgets = new WidgetsListBaseEntriesBuilder(mContext)
                 .build(mBgDataModel.widgetsModel.getWidgetsByPackageItemForPicker());
-
         executeCallbacksTask(c -> c.bindAllWidgets(widgets), mUiExecutor);
     }
 
@@ -181,10 +195,9 @@
     /**
      * Sorts the set of items by hotseat, workspace (spatially from top to bottom, left to right)
      */
-    protected void sortWorkspaceItemsSpatially(InvariantDeviceProfile profile,
-            ArrayList<ItemInfo> workspaceItems) {
-        final int screenCols = profile.numColumns;
-        final int screenCellCount = profile.numColumns * profile.numRows;
+    protected void sortWorkspaceItemsSpatially(ArrayList<ItemInfo> workspaceItems) {
+        final int screenCols = mIDP.numColumns;
+        final int screenCellCount = mIDP.numColumns * mIDP.numRows;
         Collections.sort(workspaceItems, (lhs, rhs) -> {
             if (lhs.container == rhs.container) {
                 // Within containers, order by their spatial position in that container
@@ -240,30 +253,18 @@
 
     private class UnifiedWorkspaceBinder {
 
-        private final Executor mUiExecutor;
         private final Callbacks mCallbacks;
 
-        private final LauncherAppState mApp;
-        private final BgDataModel mBgDataModel;
-
-        private final int mMyBindingId;
         private final IntSparseArrayMap<ItemInfo> mItemIdMap;
         private final IntArray mOrderedScreenIds;
         private final ArrayList<FixedContainerItems> mExtraItems;
 
-        UnifiedWorkspaceBinder(Callbacks callbacks,
-                Executor uiExecutor,
-                LauncherAppState app,
-                BgDataModel bgDataModel,
-                int myBindingId,
+        UnifiedWorkspaceBinder(
+                Callbacks callbacks,
                 IntSparseArrayMap<ItemInfo> itemIdMap,
                 ArrayList<FixedContainerItems> extraItems,
                 IntArray orderedScreenIds) {
             mCallbacks = callbacks;
-            mUiExecutor = uiExecutor;
-            mApp = app;
-            mBgDataModel = bgDataModel;
-            mMyBindingId = myBindingId;
             mItemIdMap = itemIdMap;
             mExtraItems = extraItems;
             mOrderedScreenIds = orderedScreenIds;
@@ -289,9 +290,8 @@
                     (WIDGET_FILTER.test(item) ? otherAppWidgets : otherWorkspaceItems).add(item);
                 }
             });
-            final InvariantDeviceProfile idp = mApp.getInvariantDeviceProfile();
-            sortWorkspaceItemsSpatially(idp, currentWorkspaceItems);
-            sortWorkspaceItemsSpatially(idp, otherWorkspaceItems);
+            sortWorkspaceItemsSpatially(currentWorkspaceItems);
+            sortWorkspaceItemsSpatially(otherWorkspaceItems);
 
             // Tell the workspace that we're about to start binding items
             executeCallbacksTask(c -> {
@@ -352,7 +352,7 @@
             executeCallbacksTask(c -> c.bindStringCache(cacheClone), pendingExecutor);
 
             executeCallbacksTask(c -> c.finishBindingItems(currentScreenIds), pendingExecutor);
-            pendingExecutor.execute(() -> ItemInstallQueue.INSTANCE.get(mApp.getContext())
+            pendingExecutor.execute(() -> ItemInstallQueue.INSTANCE.get(mContext)
                     .resumeModelPush(FLAG_LOADER_RUNNING));
         }
 
@@ -367,8 +367,8 @@
                 return;
             }
 
-            ModelWriter writer = mApp.getModel()
-                    .getWriter(false /* verifyChanges */, CellPosMapper.DEFAULT, null);
+            ModelWriter writer = mModel.getWriter(
+                    false /* verifyChanges */, CellPosMapper.DEFAULT, null);
             List<Pair<ItemInfo, View>> bindItems = items.stream()
                     .map(i -> Pair.create(i, inflater.inflateItem(i, writer, null)))
                     .collect(Collectors.toList());
@@ -398,4 +398,9 @@
             });
         }
     }
+
+    @AssistedFactory
+    public interface BaseLauncherBinderFactory {
+        BaseLauncherBinder createBinder(Callbacks[] callbacks);
+    }
 }
diff --git a/src/com/android/launcher3/model/BgDataModel.java b/src/com/android/launcher3/model/BgDataModel.java
index d9eccaf..ea9f36c 100644
--- a/src/com/android/launcher3/model/BgDataModel.java
+++ b/src/com/android/launcher3/model/BgDataModel.java
@@ -46,6 +46,7 @@
 import com.android.launcher3.BuildConfig;
 import com.android.launcher3.Workspace;
 import com.android.launcher3.config.FeatureFlags;
+import com.android.launcher3.dagger.LauncherAppSingleton;
 import com.android.launcher3.logging.FileLog;
 import com.android.launcher3.model.data.AppInfo;
 import com.android.launcher3.model.data.CollectionInfo;
@@ -79,9 +80,15 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
+import javax.inject.Inject;
+
 /**
  * All the data stored in-memory and managed by the LauncherModel
+ *
+ * All the static data should be accessed on the background thread, A lock should be acquired on
+ * this object when accessing any data from this model.
  */
+@LauncherAppSingleton
 public class BgDataModel {
 
     private static final String TAG = "BgDataModel";
@@ -105,7 +112,7 @@
     /**
      * Entire list of widgets.
      */
-    public final WidgetsModel widgetsModel = new WidgetsModel();
+    public final WidgetsModel widgetsModel;
 
     /**
      * Cache for strings used in launcher
@@ -124,6 +131,11 @@
     public boolean isFirstPagePinnedItemEnabled = QSB_ON_FIRST_SCREEN
             && !enableSmartspaceRemovalToggle();
 
+    @Inject
+    public BgDataModel(WidgetsModel widgetsModel) {
+        this.widgetsModel = widgetsModel;
+    }
+
     /**
      * Clears all the data
      */
diff --git a/src/com/android/launcher3/model/CacheDataUpdatedTask.java b/src/com/android/launcher3/model/CacheDataUpdatedTask.java
index 48934e2..f740b49 100644
--- a/src/com/android/launcher3/model/CacheDataUpdatedTask.java
+++ b/src/com/android/launcher3/model/CacheDataUpdatedTask.java
@@ -59,7 +59,7 @@
     @Override
     public void execute(@NonNull ModelTaskController taskController, @NonNull BgDataModel dataModel,
             @NonNull AllAppsList apps) {
-        IconCache iconCache = taskController.getApp().getIconCache();
+        IconCache iconCache = taskController.getIconCache();
         ArrayList<ItemInfo> updatedItems = new ArrayList<>();
 
         synchronized (dataModel) {
diff --git a/src/com/android/launcher3/model/FirstScreenBroadcast.java b/src/com/android/launcher3/model/FirstScreenBroadcast.java
index f443f81..829e0fe 100644
--- a/src/com/android/launcher3/model/FirstScreenBroadcast.java
+++ b/src/com/android/launcher3/model/FirstScreenBroadcast.java
@@ -45,9 +45,9 @@
 
 import java.util.ArrayList;
 import java.util.Collections;
-import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 import java.util.stream.Collectors;
 
@@ -76,9 +76,9 @@
 
     private static final String VERIFICATION_TOKEN_EXTRA = "verificationToken";
 
-    private final HashMap<PackageUserKey, SessionInfo> mSessionInfoForPackage;
+    private final Map<PackageUserKey, SessionInfo> mSessionInfoForPackage;
 
-    public FirstScreenBroadcast(HashMap<PackageUserKey, SessionInfo> sessionInfoForPackage) {
+    public FirstScreenBroadcast(Map<PackageUserKey, SessionInfo> sessionInfoForPackage) {
         mSessionInfoForPackage = sessionInfoForPackage;
     }
 
diff --git a/src/com/android/launcher3/model/GridSizeMigrationDBController.java b/src/com/android/launcher3/model/GridSizeMigrationDBController.java
index 5d0a7bd..3e43943 100644
--- a/src/com/android/launcher3/model/GridSizeMigrationDBController.java
+++ b/src/com/android/launcher3/model/GridSizeMigrationDBController.java
@@ -20,6 +20,8 @@
 import static com.android.launcher3.LauncherSettings.Favorites.TABLE_NAME;
 import static com.android.launcher3.LauncherSettings.Favorites.TMP_TABLE;
 import static com.android.launcher3.Utilities.SHOULD_SHOW_FIRST_PAGE_WIDGET;
+import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_ROW_SHIFT_GRID_MIGRATION;
+import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_STANDARD_GRID_MIGRATION;
 import static com.android.launcher3.model.LoaderTask.SMARTSPACE_ON_HOME_SCREEN;
 import static com.android.launcher3.provider.LauncherDbUtils.copyTable;
 import static com.android.launcher3.provider.LauncherDbUtils.dropTable;
@@ -44,6 +46,7 @@
 import com.android.launcher3.LauncherSettings;
 import com.android.launcher3.Utilities;
 import com.android.launcher3.config.FeatureFlags;
+import com.android.launcher3.logging.StatsLogManager;
 import com.android.launcher3.provider.LauncherDbUtils.SQLiteTransaction;
 import com.android.launcher3.util.GridOccupancy;
 import com.android.launcher3.util.IntArray;
@@ -127,6 +130,8 @@
             return true;
         }
 
+        StatsLogManager statsLogManager = StatsLogManager.newInstance(context);
+
         boolean shouldMigrateToStrictlyTallerGrid = (Flags.oneGridSpecs() || isDestNewDb)
                 && srcDeviceState.getColumns().equals(destDeviceState.getColumns())
                 && srcDeviceState.getRows() < destDeviceState.getRows();
@@ -152,6 +157,7 @@
                 // Save current configuration, so that the migration does not run again.
                 destDeviceState.writeToPrefs(context);
                 t.commit();
+                statsLogManager.logger().log(LAUNCHER_ROW_SHIFT_GRID_MIGRATION);
                 return true;
             }
 
@@ -163,6 +169,7 @@
                     destDeviceState.getNumHotseat(), targetSize, srcDeviceState, destDeviceState);
             dropTable(t.getDb(), TMP_TABLE);
             t.commit();
+            statsLogManager.logger().log(LAUNCHER_STANDARD_GRID_MIGRATION);
             return true;
         } catch (Exception e) {
             Log.e(TAG, "Error during grid migration", e);
diff --git a/src/com/android/launcher3/model/GridSizeMigrationLogic.kt b/src/com/android/launcher3/model/GridSizeMigrationLogic.kt
index 5df135a..2957e3c 100644
--- a/src/com/android/launcher3/model/GridSizeMigrationLogic.kt
+++ b/src/com/android/launcher3/model/GridSizeMigrationLogic.kt
@@ -30,6 +30,9 @@
 import com.android.launcher3.Utilities
 import com.android.launcher3.config.FeatureFlags
 import com.android.launcher3.logging.FileLog
+import com.android.launcher3.logging.StatsLogManager
+import com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_ROW_SHIFT_GRID_MIGRATION
+import com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_STANDARD_GRID_MIGRATION
 import com.android.launcher3.model.GridSizeMigrationDBController.DbReader
 import com.android.launcher3.provider.LauncherDbUtils.SQLiteTransaction
 import com.android.launcher3.provider.LauncherDbUtils.copyTable
@@ -58,6 +61,8 @@
             return
         }
 
+        val statsLogManager: StatsLogManager = StatsLogManager.newInstance(context)
+
         val isAfterRestore = get(context).get(LauncherPrefs.IS_FIRST_LOAD_AFTER_RESTORE)
         FileLog.d(
             TAG,
@@ -90,6 +95,7 @@
                     // Save current configuration, so that the migration does not run again.
                     destDeviceState.writeToPrefs(context)
                     t.commit()
+                    statsLogManager.logger().log(LAUNCHER_ROW_SHIFT_GRID_MIGRATION)
                     return
                 }
 
@@ -119,6 +125,7 @@
 
                 dropTable(t.db, TMP_TABLE)
                 t.commit()
+                statsLogManager.logger().log(LAUNCHER_STANDARD_GRID_MIGRATION)
             }
         } catch (e: Exception) {
             FileLog.e(TAG, "Error during grid migration", e)
diff --git a/src/com/android/launcher3/model/LoaderCursor.java b/src/com/android/launcher3/model/LoaderCursor.java
index bd8c36b..efe6157 100644
--- a/src/com/android/launcher3/model/LoaderCursor.java
+++ b/src/com/android/launcher3/model/LoaderCursor.java
@@ -21,7 +21,6 @@
 import static com.android.launcher3.LauncherSettings.Favorites.ITEM_TYPE_APPLICATION;
 import static com.android.launcher3.LauncherSettings.Favorites.ITEM_TYPE_APP_PAIR;
 import static com.android.launcher3.LauncherSettings.Favorites.ITEM_TYPE_DEEP_SHORTCUT;
-import static com.android.launcher3.LauncherSettings.Favorites.TABLE_NAME;
 import static com.android.launcher3.Utilities.SHOULD_SHOW_FIRST_PAGE_WIDGET;
 import static com.android.launcher3.icons.cache.CacheLookupFlag.DEFAULT_LOOKUP_FLAG;
 import static com.android.launcher3.model.data.ItemInfoWithIcon.FLAG_ARCHIVED;
@@ -45,13 +44,14 @@
 
 import com.android.launcher3.Flags;
 import com.android.launcher3.InvariantDeviceProfile;
-import com.android.launcher3.LauncherAppState;
+import com.android.launcher3.LauncherModel;
 import com.android.launcher3.LauncherSettings.Favorites;
 import com.android.launcher3.Utilities;
 import com.android.launcher3.Workspace;
 import com.android.launcher3.backuprestore.LauncherRestoreEventLogger;
 import com.android.launcher3.backuprestore.LauncherRestoreEventLogger.RestoreError;
 import com.android.launcher3.config.FeatureFlags;
+import com.android.launcher3.dagger.ApplicationContext;
 import com.android.launcher3.icons.IconCache;
 import com.android.launcher3.logging.FileLog;
 import com.android.launcher3.model.data.AppInfo;
@@ -70,6 +70,10 @@
 import com.android.launcher3.util.PackageManagerHelper;
 import com.android.launcher3.util.UserIconInfo;
 
+import dagger.assisted.Assisted;
+import dagger.assisted.AssistedFactory;
+import dagger.assisted.AssistedInject;
+
 import java.net.URISyntaxException;
 import java.security.InvalidParameterException;
 
@@ -82,8 +86,8 @@
 
     private final LongSparseArray<UserHandle> allUsers;
 
-    private final LauncherAppState mApp;
     private final Context mContext;
+    private final LauncherModel mModel;
     private final PackageManagerHelper mPmHelper;
     private final IconCache mIconCache;
     private final InvariantDeviceProfile mIDP;
@@ -130,17 +134,24 @@
     public int itemType;
     public int restoreFlag;
 
-    public LoaderCursor(Cursor cursor, LauncherAppState app, UserManagerState userManagerState,
-            PackageManagerHelper pmHelper,
-            @Nullable LauncherRestoreEventLogger restoreEventLogger) {
+    @AssistedInject
+    public LoaderCursor(
+            @Assisted Cursor cursor,
+            @Assisted UserManagerState userManagerState,
+            @Assisted @Nullable LauncherRestoreEventLogger restoreEventLogger,
+            @ApplicationContext Context context,
+            IconCache iconCache,
+            InvariantDeviceProfile idp,
+            LauncherModel model,
+            PackageManagerHelper pmHelper) {
         super(cursor);
-
-        mApp = app;
-        allUsers = userManagerState.allUsers;
-        mContext = app.getContext();
-        mIconCache = app.getIconCache();
+        mContext = context;
+        mIconCache = iconCache;
+        mIDP = idp;
+        mModel = model;
         mPmHelper = pmHelper;
-        mIDP = app.getInvariantDeviceProfile();
+
+        allUsers = userManagerState.allUsers;
         mRestoreEventLogger = restoreEventLogger;
 
         // Init column indices
@@ -432,7 +443,7 @@
      */
     public ContentWriter updater() {
        return new ContentWriter(mContext, new ContentWriter.CommitParams(
-               mApp.getModel().getModelDbController(),
+               mModel.getModelDbController(),
                BaseColumns._ID + "= ?", new String[]{Integer.toString(id)}));
     }
 
@@ -454,7 +465,7 @@
     public boolean commitDeleted() {
         if (mItemsToRemove.size() > 0) {
             // Remove dead items
-            mApp.getModel().getModelDbController().delete(TABLE_NAME,
+            mModel.getModelDbController().delete(
                     Utilities.createDbSelectionQuery(Favorites._ID, mItemsToRemove), null);
             return true;
         }
@@ -480,7 +491,7 @@
             // Update restored items that no longer require special handling
             ContentValues values = new ContentValues();
             values.put(Favorites.RESTORED, 0);
-            mApp.getModel().getModelDbController().update(TABLE_NAME, values,
+            mModel.getModelDbController().update(values,
                     Utilities.createDbSelectionQuery(Favorites._ID, mRestoredRows), null);
         }
         if (mRestoreEventLogger != null) {
@@ -645,4 +656,12 @@
             return false;
         }
     }
+
+    @AssistedFactory
+    public interface LoaderCursorFactory {
+
+        LoaderCursor createLoaderCursor(Cursor cursor,
+                UserManagerState userManagerState,
+                @Nullable LauncherRestoreEventLogger restoreEventLogger);
+    }
 }
diff --git a/src/com/android/launcher3/model/LoaderTask.java b/src/com/android/launcher3/model/LoaderTask.java
index fb1ebaf..78e5d89 100644
--- a/src/com/android/launcher3/model/LoaderTask.java
+++ b/src/com/android/launcher3/model/LoaderTask.java
@@ -23,7 +23,6 @@
 import static com.android.launcher3.LauncherPrefs.IS_FIRST_LOAD_AFTER_RESTORE;
 import static com.android.launcher3.LauncherPrefs.SHOULD_SHOW_SMARTSPACE;
 import static com.android.launcher3.LauncherSettings.Favorites.DESKTOP_ICON_FLAG;
-import static com.android.launcher3.LauncherSettings.Favorites.TABLE_NAME;
 import static com.android.launcher3.icons.CacheableShortcutInfo.convertShortcutsToCacheableShortcuts;
 import static com.android.launcher3.icons.cache.CacheLookupFlag.DEFAULT_LOOKUP_FLAG;
 import static com.android.launcher3.model.BgDataModel.Callbacks.FLAG_HAS_SHORTCUT_PERMISSION;
@@ -53,7 +52,6 @@
 import android.os.UserHandle;
 import android.os.UserManager;
 import android.provider.Settings;
-import android.util.ArrayMap;
 import android.util.Log;
 import android.util.LongSparseArray;
 
@@ -63,13 +61,14 @@
 import androidx.annotation.WorkerThread;
 
 import com.android.launcher3.Flags;
-import com.android.launcher3.LauncherAppState;
+import com.android.launcher3.InvariantDeviceProfile;
 import com.android.launcher3.LauncherModel;
 import com.android.launcher3.LauncherPrefs;
 import com.android.launcher3.LauncherSettings.Favorites;
 import com.android.launcher3.Utilities;
 import com.android.launcher3.backuprestore.LauncherRestoreEventLogger;
 import com.android.launcher3.config.FeatureFlags;
+import com.android.launcher3.dagger.ApplicationContext;
 import com.android.launcher3.folder.Folder;
 import com.android.launcher3.folder.FolderGridOrganizer;
 import com.android.launcher3.folder.FolderNameInfos;
@@ -82,6 +81,7 @@
 import com.android.launcher3.icons.cache.IconCacheUpdateHandler;
 import com.android.launcher3.icons.cache.LauncherActivityCachingLogic;
 import com.android.launcher3.logging.FileLog;
+import com.android.launcher3.model.LoaderCursor.LoaderCursorFactory;
 import com.android.launcher3.model.data.AppInfo;
 import com.android.launcher3.model.data.AppPairInfo;
 import com.android.launcher3.model.data.FolderInfo;
@@ -106,6 +106,10 @@
 import com.android.launcher3.util.TraceHelper;
 import com.android.launcher3.widget.WidgetInflater;
 
+import dagger.assisted.Assisted;
+import dagger.assisted.AssistedFactory;
+import dagger.assisted.AssistedInject;
+
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
@@ -117,6 +121,8 @@
 import java.util.Set;
 import java.util.concurrent.CancellationException;
 
+import javax.inject.Named;
+
 /**
  * Runnable for the thread that loads the contents of the launcher:
  *   - workspace icons
@@ -131,10 +137,14 @@
 
     private static final boolean DEBUG = true;
 
-    @NonNull
-    protected final LauncherAppState mApp;
+    private final Context mContext;
+    private final LauncherModel mModel;
+    private final InvariantDeviceProfile mIDP;
+    private final boolean mIsSafeModeEnabled;
     private final AllAppsList mBgAllAppsList;
     protected final BgDataModel mBgDataModel;
+    private final LoaderCursorFactory mLoaderCursorFactory;
+
     private final ModelDelegate mModelDelegate;
     private boolean mIsRestoreFromBackup;
 
@@ -152,7 +162,6 @@
     private final IconCache mIconCache;
 
     private final UserManagerState mUserManagerState;
-    protected final Map<ComponentKey, AppWidgetProviderInfo> mWidgetProvidersMap = new ArrayMap<>();
     private Map<ShortcutKey, ShortcutInfo> mShortcutKeyToPinnedShortcuts;
     private HashMap<PackageUserKey, SessionInfo> mInstallingPkgsCached;
 
@@ -164,26 +173,36 @@
     private boolean mItemsDeleted = false;
     private String mDbName;
 
-    public LoaderTask(@NonNull LauncherAppState app, AllAppsList bgAllAppsList, BgDataModel bgModel,
-            ModelDelegate modelDelegate, @NonNull BaseLauncherBinder launcherBinder) {
-        this(app, bgAllAppsList, bgModel, modelDelegate, launcherBinder, new UserManagerState());
-    }
-
-    @VisibleForTesting
-    LoaderTask(@NonNull LauncherAppState app, AllAppsList bgAllAppsList, BgDataModel bgModel,
-            ModelDelegate modelDelegate, @NonNull BaseLauncherBinder launcherBinder,
-            UserManagerState userManagerState) {
-        mApp = app;
+    @AssistedInject
+    LoaderTask(
+            @ApplicationContext Context context,
+            InvariantDeviceProfile idp,
+            LauncherModel model,
+            UserCache userCache,
+            PackageManagerHelper pmHelper,
+            InstallSessionHelper sessionHelper,
+            IconCache iconCache,
+            AllAppsList bgAllAppsList,
+            BgDataModel bgModel,
+            LoaderCursorFactory loaderCursorFactory,
+            @Named("SAFE_MODE") boolean isSafeModeEnabled,
+            @Assisted @NonNull BaseLauncherBinder launcherBinder,
+            @Assisted UserManagerState userManagerState) {
+        mContext = context;
+        mIDP = idp;
+        mModel = model;
+        mIsSafeModeEnabled = isSafeModeEnabled;
         mBgAllAppsList = bgAllAppsList;
         mBgDataModel = bgModel;
-        mModelDelegate = modelDelegate;
+        mModelDelegate = model.getModelDelegate();
         mLauncherBinder = launcherBinder;
-        mLauncherApps = mApp.getContext().getSystemService(LauncherApps.class);
-        mUserManager = mApp.getContext().getSystemService(UserManager.class);
-        mUserCache = UserCache.INSTANCE.get(mApp.getContext());
-        mPmHelper = PackageManagerHelper.INSTANCE.get(mApp.getContext());
-        mSessionHelper = InstallSessionHelper.INSTANCE.get(mApp.getContext());
-        mIconCache = mApp.getIconCache();
+        mLoaderCursorFactory = loaderCursorFactory;
+        mLauncherApps = mContext.getSystemService(LauncherApps.class);
+        mUserManager = mContext.getSystemService(UserManager.class);
+        mUserCache = userCache;
+        mPmHelper = pmHelper;
+        mSessionHelper = sessionHelper;
+        mIconCache = iconCache;
         mUserManagerState = userManagerState;
         mInstallingPkgsCached = null;
     }
@@ -215,7 +234,7 @@
                         .filter(currentScreenContentFilter(firstScreens))
                         .toList();
         final int disableArchivingLauncherBroadcast = Settings.Secure.getInt(
-                mApp.getContext().getContentResolver(),
+                mContext.getContentResolver(),
                 "disable_launcher_broadcast_installed_apps",
                 /* default */ 0);
         boolean shouldAttachArchivingExtras = mIsRestoreFromBackup
@@ -230,10 +249,10 @@
                             mBgDataModel.itemsIdMap.stream().filter(WIDGET_FILTER).toList()
                     );
             logASplit("Sending first screen broadcast with additional archiving Extras");
-            FirstScreenBroadcastHelper.sendBroadcastsForModels(mApp.getContext(), broadcastModels);
+            FirstScreenBroadcastHelper.sendBroadcastsForModels(mContext, broadcastModels);
         } else {
             logASplit("Sending first screen broadcast");
-            mFirstScreenBroadcast.sendBroadcasts(mApp.getContext(), firstScreenItems);
+            mFirstScreenBroadcast.sendBroadcasts(mContext, firstScreenItems);
         }
     }
 
@@ -249,16 +268,14 @@
         MODEL_EXECUTOR.elevatePriority(CALLER_LOADER_TASK);
         LoaderMemoryLogger memoryLogger = new LoaderMemoryLogger();
         mIsRestoreFromBackup =
-                LauncherPrefs.get(mApp.getContext()).get(IS_FIRST_LOAD_AFTER_RESTORE);
+                LauncherPrefs.get(mContext).get(IS_FIRST_LOAD_AFTER_RESTORE);
         LauncherRestoreEventLogger restoreEventLogger = null;
         if (enableLauncherBrMetricsFixed()) {
-            restoreEventLogger = LauncherRestoreEventLogger.Companion
-                    .newInstance(mApp.getContext());
+            restoreEventLogger = LauncherRestoreEventLogger.Companion.newInstance(mContext);
         }
-        try (LauncherModel.LoaderTransaction transaction = mApp.getModel().beginLoader(this)) {
-
+        try (LauncherModel.LoaderTransaction transaction = mModel.beginLoader(this)) {
             List<CacheableShortcutInfo> allShortcuts = new ArrayList<>();
-            loadWorkspace(allShortcuts, "", memoryLogger, restoreEventLogger);
+            loadWorkspace(allShortcuts, "", new HashMap<>(), memoryLogger, restoreEventLogger);
 
             // Sanitize data re-syncs widgets/shortcuts based on the workspace loaded from db.
             // sanitizeData should not be invoked if the workspace is loaded from a db different
@@ -267,7 +284,7 @@
             // TODO(b/384731096): Write Unit Test to make sure sanitizeWidgetsShortcutsAndPackages
             //  actually re-pins shortcuts that are in model but not in ShortcutManager, if possible
             //  after a simulated restore.
-            if (Objects.equals(mApp.getInvariantDeviceProfile().dbFile, mDbName)) {
+            if (Objects.equals(mIDP.dbFile, mDbName)) {
                 verifyNotStopped();
                 sanitizeFolders(mItemsDeleted);
                 sanitizeAppPairs();
@@ -307,13 +324,13 @@
             setIgnorePackages(updateHandler);
             updateHandler.updateIcons(allActivityList,
                     LauncherActivityCachingLogic.INSTANCE,
-                    mApp.getModel()::onPackageIconsUpdated);
+                    mModel::onPackageIconsUpdated);
             logASplit("update AllApps icon cache finished");
 
             verifyNotStopped();
             logASplit("saving all shortcuts in icon cache");
             updateHandler.updateIcons(allShortcuts, CacheableShortcutCachingLogic.INSTANCE,
-                    mApp.getModel()::onPackageIconsUpdated);
+                    mModel::onPackageIconsUpdated);
 
             // Take a break
             waitForIdle();
@@ -342,14 +359,14 @@
 
             // fourth step
             WidgetsModel widgetsModel = mBgDataModel.widgetsModel;
-            List<CachedObject> allWidgetsList = widgetsModel.update(mApp, /*packageUser=*/null);
+            List<CachedObject> allWidgetsList = widgetsModel.update(/*packageUser=*/null);
             logASplit("load widgets finished");
 
             verifyNotStopped();
             mLauncherBinder.bindWidgets();
             logASplit("bindWidgets finished");
             verifyNotStopped();
-            LauncherPrefs prefs = LauncherPrefs.get(mApp.getContext());
+            LauncherPrefs prefs = LauncherPrefs.get(mContext);
 
             if (enableSmartspaceAsAWidget() && prefs.get(SHOULD_SHOW_SMARTSPACE)) {
                 mLauncherBinder.bindSmartspaceWidget();
@@ -366,7 +383,7 @@
             logASplit("saving all widgets in icon cache");
             updateHandler.updateIcons(allWidgetsList,
                     CachedObjectCachingLogic.INSTANCE,
-                    mApp.getModel()::onWidgetLabelsUpdated);
+                    mModel::onWidgetLabelsUpdated);
 
             // fifth step
             loadFolderNames();
@@ -380,7 +397,7 @@
             memoryLogger.clearLogs();
             if (mIsRestoreFromBackup) {
                 mIsRestoreFromBackup = false;
-                LauncherPrefs.get(mApp.getContext()).putSync(IS_FIRST_LOAD_AFTER_RESTORE.to(false));
+                LauncherPrefs.get(mContext).putSync(IS_FIRST_LOAD_AFTER_RESTORE.to(false));
                 if (restoreEventLogger != null) {
                     restoreEventLogger.reportLauncherRestoreResults();
                 }
@@ -402,35 +419,42 @@
         this.notify();
     }
 
-    protected void loadWorkspace(
+    public void loadWorkspaceForPreview(String selection,
+            Map<ComponentKey, AppWidgetProviderInfo> widgetProviderInfoMap) {
+        loadWorkspace(new ArrayList<>(), selection, widgetProviderInfoMap, null, null);
+    }
+
+    private void loadWorkspace(
             List<CacheableShortcutInfo> allDeepShortcuts,
             String selection,
+            Map<ComponentKey, AppWidgetProviderInfo> widgetProviderInfoMap,
             @Nullable LoaderMemoryLogger memoryLogger,
             @Nullable LauncherRestoreEventLogger restoreEventLogger
     ) {
         Trace.beginSection("LoadWorkspace");
         try {
-            loadWorkspaceImpl(allDeepShortcuts, selection, memoryLogger, restoreEventLogger);
+            loadWorkspaceImpl(allDeepShortcuts, selection, widgetProviderInfoMap,
+                    memoryLogger, restoreEventLogger);
         } finally {
             Trace.endSection();
         }
         logASplit("loadWorkspace finished");
 
         mBgDataModel.isFirstPagePinnedItemEnabled = FeatureFlags.QSB_ON_FIRST_SCREEN
-                && (!enableSmartspaceRemovalToggle() || LauncherPrefs.getPrefs(
-                mApp.getContext()).getBoolean(SMARTSPACE_ON_HOME_SCREEN, true));
+                && (!enableSmartspaceRemovalToggle()
+                || LauncherPrefs.getPrefs(mContext).getBoolean(SMARTSPACE_ON_HOME_SCREEN, true));
     }
 
     private void loadWorkspaceImpl(
             List<CacheableShortcutInfo> allDeepShortcuts,
             String selection,
+            Map<ComponentKey, AppWidgetProviderInfo> widgetProviderInfoMap,
             @Nullable LoaderMemoryLogger memoryLogger,
             @Nullable LauncherRestoreEventLogger restoreEventLogger) {
-        final Context context = mApp.getContext();
         final boolean isSdCardReady = Utilities.isBootCompleted();
-        final WidgetInflater widgetInflater = new WidgetInflater(context);
+        final WidgetInflater widgetInflater = new WidgetInflater(mContext, mIsSafeModeEnabled);
 
-        ModelDbController dbController = mApp.getModel().getModelDbController();
+        ModelDbController dbController = mModel.getModelDbController();
         if (Flags.gridMigrationRefactor()) {
             try {
                 dbController.attemptMigrateDb(restoreEventLogger, mModelDelegate);
@@ -452,28 +476,29 @@
             if (Flags.enableSupportForArchiving()) {
                 mInstallingPkgsCached = installingPkgs;
             }
-            installingPkgs.forEach(mApp.getIconCache()::updateSessionCache);
+            installingPkgs.forEach(mIconCache::updateSessionCache);
             FileLog.d(TAG, "loadWorkspace: Packages with active install/update sessions: "
                     + installingPkgs.keySet().stream().map(info -> info.mPackageName).toList());
 
             mFirstScreenBroadcast = new FirstScreenBroadcast(installingPkgs);
 
             mShortcutKeyToPinnedShortcuts = new HashMap<>();
-            final LoaderCursor c = new LoaderCursor(
-                    dbController.query(TABLE_NAME, null, selection, null, null),
-                    mApp, mUserManagerState, mPmHelper,
+            final LoaderCursor c = mLoaderCursorFactory.createLoaderCursor(
+                    dbController.query(null, selection, null, null),
+                    mUserManagerState,
                     mIsRestoreFromBackup ? restoreEventLogger : null);
             final Bundle extras = c.getExtras();
             mDbName = extras == null ? null : extras.getString(ModelDbController.EXTRA_DB_NAME);
             try {
                 final LongSparseArray<Boolean> unlockedUsers = new LongSparseArray<>();
-                queryPinnedShortcutsForUnlockedUsers(context, unlockedUsers);
+                queryPinnedShortcutsForUnlockedUsers(mContext, unlockedUsers);
 
                 mWorkspaceIconRequestInfos = new ArrayList<>();
                 WorkspaceItemProcessor itemProcessor = new WorkspaceItemProcessor(c, memoryLogger,
                         mUserCache, mUserManagerState, mLauncherApps, mPendingPackages,
-                        mShortcutKeyToPinnedShortcuts, mApp, mBgDataModel,
-                        mWidgetProvidersMap, installingPkgs, isSdCardReady,
+                        mShortcutKeyToPinnedShortcuts, mContext, mIDP, mIconCache,
+                        mIsSafeModeEnabled, mBgDataModel,
+                        widgetProviderInfoMap, installingPkgs, isSdCardReady,
                         widgetInflater, mPmHelper, mWorkspaceIconRequestInfos, unlockedUsers,
                         allDeepShortcuts);
 
@@ -577,7 +602,7 @@
     @WorkerThread
     private void processFolderItems() {
         // Sort the folder items, update ranks, and make sure all preview items are high res.
-        List<FolderGridOrganizer> verifiers = mApp.getInvariantDeviceProfile().supportedProfiles
+        List<FolderGridOrganizer> verifiers = mIDP.supportedProfiles
                 .stream().map(FolderGridOrganizer::createFolderGridOrganizer).toList();
         for (ItemInfo itemInfo : mBgDataModel.itemsIdMap) {
             if (!(itemInfo instanceof FolderInfo folder)) {
@@ -617,7 +642,7 @@
                 if (mIconCache.isDefaultIcon(wai.bitmap, wai.user)) {
                     logASplit("tryLoadWorkspaceIconsInBulk: default icon found for "
                             + wai.getTargetComponent() + ", will attempt to load from iconBlob");
-                    iconRequestInfo.loadIconFromDbBlob(mApp.getContext());
+                    iconRequestInfo.loadIconFromDbBlob(mContext);
                 }
             }
         } finally {
@@ -649,7 +674,7 @@
     private void sanitizeFolders(boolean itemsDeleted) {
         if (itemsDeleted) {
             // Remove any empty folder
-            IntArray deletedFolderIds = mApp.getModel().getModelDbController().deleteEmptyFolders();
+            IntArray deletedFolderIds = mModel.getModelDbController().deleteEmptyFolders();
             synchronized (mBgDataModel) {
                 for (int folderId : deletedFolderIds) {
                     mBgDataModel.itemsIdMap.remove(folderId);
@@ -660,8 +685,8 @@
 
     /** Cleans up app pairs if they don't have the right number of member apps (2). */
     private void sanitizeAppPairs() {
-        IntArray deletedAppPairIds = mApp.getModel().getModelDbController().deleteBadAppPairs();
-        IntArray deletedAppIds = mApp.getModel().getModelDbController().deleteUnparentedApps();
+        IntArray deletedAppPairIds = mModel.getModelDbController().deleteBadAppPairs();
+        IntArray deletedAppIds = mModel.getModelDbController().deleteUnparentedApps();
 
         IntArray deleted = new IntArray();
         deleted.addAll(deletedAppPairIds);
@@ -675,17 +700,15 @@
     }
 
     private void sanitizeWidgetsShortcutsAndPackages() {
-        Context context = mApp.getContext();
-
         // Remove any ghost widgets
-        mApp.getModel().getModelDbController().removeGhostWidgets();
+        mModel.getModelDbController().removeGhostWidgets();
 
         // Update pinned state of model shortcuts
-        mBgDataModel.updateShortcutPinnedState(context);
+        mBgDataModel.updateShortcutPinnedState(mContext);
 
         if (!Utilities.isBootCompleted() && !mPendingPackages.isEmpty()) {
-            context.registerReceiver(
-                    new SdCardAvailableReceiver(mApp, mPendingPackages),
+            mContext.registerReceiver(
+                    new SdCardAvailableReceiver(mContext, mModel, mPendingPackages),
                     new IntentFilter(Intent.ACTION_BOOT_COMPLETED),
                     null,
                     MODEL_EXECUTOR.getHandler());
@@ -722,7 +745,7 @@
             for (int i = 0; i < apps.size(); i++) {
                 LauncherActivityInfo app = apps.get(i);
                 AppInfo appInfo = new AppInfo(app, mUserCache.getUserInfo(user),
-                        ApiWrapper.INSTANCE.get(mApp.getContext()), mPmHelper, quietMode);
+                        ApiWrapper.INSTANCE.get(mContext), mPmHelper, quietMode);
                 if (Flags.enableSupportForArchiving() && app.getApplicationInfo().isArchived) {
                     // For archived apps, include progress info in case there is a pending
                     // install session post restart of device.
@@ -751,7 +774,7 @@
             for (PackageInstaller.SessionInfo info :
                     mSessionHelper.getAllVerifiedSessions()) {
                 AppInfo promiseAppInfo = mBgAllAppsList.addPromiseApp(
-                        mApp.getContext(),
+                        mContext,
                         PackageInstallInfo.fromInstallingState(info),
                         false);
 
@@ -776,7 +799,7 @@
                                 + appInfo.getTargetComponent()
                                 + ", will attempt to load from iconBlob: "
                                 + Arrays.toString(iconRequestInfo.iconBlob));
-                        iconRequestInfo.loadIconFromDbBlob(mApp.getContext());
+                        iconRequestInfo.loadIconFromDbBlob(mContext);
                     }
                 }
             }
@@ -794,9 +817,9 @@
                     mUserManagerState.isAnyProfileQuietModeEnabled());
         }
         mBgAllAppsList.setFlags(FLAG_HAS_SHORTCUT_PERMISSION,
-                hasShortcutsPermission(mApp.getContext()));
+                hasShortcutsPermission(mContext));
         mBgAllAppsList.setFlags(FLAG_QUIET_MODE_CHANGE_PERMISSION,
-                mApp.getContext().checkSelfPermission("android.permission.MODIFY_QUIET_MODE")
+                mContext.checkSelfPermission("android.permission.MODIFY_QUIET_MODE")
                         == PackageManager.PERMISSION_GRANTED);
 
         mBgAllAppsList.getAndResetChangeFlag();
@@ -827,7 +850,7 @@
                         workspaceIconRequest.get().iconBlob,
                         false /* useLowResIcon= */
                 );
-                if (!iconRequestInfo.loadIconFromDbBlob(mApp.getContext())) {
+                if (!iconRequestInfo.loadIconFromDbBlob(mContext)) {
                     Log.d(TAG, "AppInfo Icon failed to load from blob, using cache.");
                     mIconCache.getTitleAndIcon(
                             appInfo,
@@ -853,7 +876,7 @@
         if (mBgAllAppsList.hasShortcutHostPermission()) {
             for (UserHandle user : mUserCache.getUserProfiles()) {
                 if (mUserManager.isUserUnlocked(user)) {
-                    List<ShortcutInfo> shortcuts = new ShortcutRequest(mApp.getContext(), user)
+                    List<ShortcutInfo> shortcuts = new ShortcutRequest(mContext, user)
                             .query(ShortcutRequest.ALL);
                     allShortcuts.addAll(shortcuts);
                     mBgDataModel.updateDeepShortcutCounts(null, user, shortcuts);
@@ -864,7 +887,7 @@
     }
 
     private void loadFolderNames() {
-        FolderNameProvider provider = FolderNameProvider.newInstance(mApp.getContext(),
+        FolderNameProvider provider = FolderNameProvider.newInstance(mContext,
                 mBgAllAppsList.data, FolderNameProvider.getCollectionForSuggestions(mBgDataModel));
 
         synchronized (mBgDataModel) {
@@ -874,7 +897,7 @@
                     .forEach(info -> {
                         FolderInfo fi = (FolderInfo) info;
                         FolderNameInfos suggestionInfos = new FolderNameInfos();
-                        provider.getSuggestedFolderName(mApp.getContext(), fi.getAppContents(),
+                        provider.getSuggestedFolderName(mContext, fi.getAppContents(),
                                 suggestionInfos);
                         fi.suggestedFolderNames = suggestionInfos;
                     });
@@ -891,4 +914,10 @@
             Log.d(TAG, label);
         }
     }
+
+    @AssistedFactory
+    public interface LoaderTaskFactory {
+
+        LoaderTask newLoaderTask(BaseLauncherBinder binder, UserManagerState userState);
+    }
 }
diff --git a/src/com/android/launcher3/model/ModelDbController.java b/src/com/android/launcher3/model/ModelDbController.java
index feae632..64b9c1c 100644
--- a/src/com/android/launcher3/model/ModelDbController.java
+++ b/src/com/android/launcher3/model/ModelDbController.java
@@ -73,6 +73,8 @@
 import com.android.launcher3.Utilities;
 import com.android.launcher3.backuprestore.LauncherRestoreEventLogger;
 import com.android.launcher3.backuprestore.LauncherRestoreEventLogger.RestoreError;
+import com.android.launcher3.dagger.ApplicationContext;
+import com.android.launcher3.dagger.LauncherAppSingleton;
 import com.android.launcher3.logging.FileLog;
 import com.android.launcher3.pm.UserCache;
 import com.android.launcher3.provider.LauncherDbUtils;
@@ -91,10 +93,13 @@
 import java.util.List;
 import java.util.stream.Collectors;
 
+import javax.inject.Inject;
+
 /**
  * Utility class which maintains an instance of Launcher database and provides utility methods
  * around it.
  */
+@LauncherAppSingleton
 public class ModelDbController {
     private static final String TAG = "ModelDbController";
 
@@ -105,17 +110,25 @@
     protected DatabaseHelper mOpenHelper;
 
     private final Context mContext;
+    private final InvariantDeviceProfile mIdp;
+    private final LauncherPrefs mPrefs;
+    private final UserCache mUserCache;
 
-    public ModelDbController(Context context) {
+    @Inject
+    ModelDbController(
+            @ApplicationContext Context context,
+            InvariantDeviceProfile idp,
+            LauncherPrefs prefs,
+            UserCache userCache) {
         mContext = context;
+        mIdp = idp;
+        mPrefs = prefs;
+        mUserCache = userCache;
     }
 
     private void printDBs(String prefix) {
         try {
-            File directory = new File(
-                    mContext.getDatabasePath(InvariantDeviceProfile.INSTANCE.get(mContext).dbFile)
-                            .getParent()
-            );
+            File directory = new File(mContext.getDatabasePath(mIdp.dbFile).getParent());
             if (directory.exists()) {
                 for (File file : directory.listFiles()) {
                     Log.d("b/353505773", prefix + "Database file: " + file.getName());
@@ -130,9 +143,9 @@
 
     private synchronized void createDbIfNotExists() {
         if (mOpenHelper == null) {
-            String dbFile = LauncherPrefs.get(mContext).get(DB_FILE);
+            String dbFile = mPrefs.get(DB_FILE);
             if (dbFile.isEmpty()) {
-                dbFile = InvariantDeviceProfile.INSTANCE.get(mContext).dbFile;
+                dbFile = mIdp.dbFile;
             }
             mOpenHelper = createDatabaseHelper(false /* forMigration */, dbFile);
             printDBs("before: ");
@@ -144,7 +157,7 @@
     protected DatabaseHelper createDatabaseHelper(boolean forMigration, String dbFile) {
         // Set the flag for empty DB
         Runnable onEmptyDbCreateCallback = forMigration ? () -> { }
-                : () -> LauncherPrefs.get(mContext).putSync(getEmptyDbCreatedKey(dbFile).to(true));
+                : () -> mPrefs.putSync(getEmptyDbCreatedKey(dbFile).to(true));
 
         DatabaseHelper databaseHelper = new DatabaseHelper(mContext, dbFile,
                 this::getSerialNumberForUser, onEmptyDbCreateCallback);
@@ -169,12 +182,12 @@
      * Refer {@link SQLiteDatabase#query}
      */
     @WorkerThread
-    public Cursor query(String table, String[] projection, String selection,
+    public Cursor query(String[] projection, String selection,
             String[] selectionArgs, String sortOrder) {
         createDbIfNotExists();
         SQLiteDatabase db = mOpenHelper.getWritableDatabase();
         Cursor result = db.query(
-                table, projection, selection, selectionArgs, null, null, sortOrder);
+                TABLE_NAME, projection, selection, selectionArgs, null, null, sortOrder);
 
         final Bundle extra = new Bundle();
         extra.putString(EXTRA_DB_NAME, mOpenHelper.getDatabaseName());
@@ -186,12 +199,12 @@
      * Refer {@link SQLiteDatabase#insert(String, String, ContentValues)}
      */
     @WorkerThread
-    public int insert(String table, ContentValues initialValues) {
+    public int insert(ContentValues initialValues) {
         createDbIfNotExists();
 
         SQLiteDatabase db = mOpenHelper.getWritableDatabase();
         addModifiedTime(initialValues);
-        int rowId = mOpenHelper.dbInsertAndCheck(db, table, initialValues);
+        int rowId = mOpenHelper.dbInsertAndCheck(db, TABLE_NAME, initialValues);
         if (rowId >= 0) {
             onAddOrDeleteOp(db);
         }
@@ -202,11 +215,11 @@
      * Refer {@link SQLiteDatabase#delete(String, String, String[])}
      */
     @WorkerThread
-    public int delete(String table, String selection, String[] selectionArgs) {
+    public int delete(String selection, String[] selectionArgs) {
         createDbIfNotExists();
         SQLiteDatabase db = mOpenHelper.getWritableDatabase();
 
-        int count = db.delete(table, selection, selectionArgs);
+        int count = db.delete(TABLE_NAME, selection, selectionArgs);
         if (count > 0) {
             onAddOrDeleteOp(db);
         }
@@ -217,14 +230,12 @@
      * Refer {@link SQLiteDatabase#update(String, ContentValues, String, String[])}
      */
     @WorkerThread
-    public int update(String table, ContentValues values,
-            String selection, String[] selectionArgs) {
+    public int update(ContentValues values, String selection, String[] selectionArgs) {
         createDbIfNotExists();
 
         addModifiedTime(values);
         SQLiteDatabase db = mOpenHelper.getWritableDatabase();
-        int count = db.update(table, values, selection, selectionArgs);
-        return count;
+        return db.update(TABLE_NAME, values, selection, selectionArgs);
     }
 
     /**
@@ -261,7 +272,7 @@
     public void createEmptyDB() {
         createDbIfNotExists();
         mOpenHelper.createEmptyDB(mOpenHelper.getWritableDatabase());
-        LauncherPrefs.get(mContext).putSync(getEmptyDbCreatedKey().to(true));
+        mPrefs.putSync(getEmptyDbCreatedKey().to(true));
     }
 
     /**
@@ -292,7 +303,6 @@
                 mOpenHelper.getReadableDatabase(), Favorites.HYBRID_HOTSEAT_BACKUP_TABLE);
     }
 
-
     /**
      * Resets the launcher DB if we should reset it.
      */
@@ -302,11 +312,10 @@
         }
         FileLog.d(TAG, "resetLauncherDb: Migration failed: resetting launcher database");
         createEmptyDB();
-        LauncherPrefs.get(mContext).putSync(
-                getEmptyDbCreatedKey(mOpenHelper.getDatabaseName()).to(true));
+        mPrefs.putSync(getEmptyDbCreatedKey(mOpenHelper.getDatabaseName()).to(true));
 
         // Write the grid state to avoid another migration
-        new DeviceGridState(LauncherAppState.getIDP(mContext)).writeToPrefs(mContext);
+        new DeviceGridState(mIdp).writeToPrefs(mContext);
     }
 
     /**
@@ -326,7 +335,7 @@
     }
 
     private boolean isThereExistingDb() {
-        if (LauncherPrefs.get(mContext).get(getEmptyDbCreatedKey())) {
+        if (mPrefs.get(getEmptyDbCreatedKey())) {
             // If we already have a new DB, ignore migration
             FileLog.d(TAG, "isThereExistingDb: new DB already created, skipping migration");
             return true;
@@ -335,8 +344,7 @@
     }
 
     private boolean isGridMigrationNecessary() {
-        InvariantDeviceProfile idp = LauncherAppState.getIDP(mContext);
-        if (GridSizeMigrationDBController.needsToMigrate(mContext, idp)) {
+        if (GridSizeMigrationDBController.needsToMigrate(mContext, mIdp)) {
             return true;
         }
         FileLog.d(TAG, "isGridMigrationNecessary: no grid migration needed");
@@ -344,8 +352,7 @@
     }
 
     private boolean isCurrentDbSameAsTarget() {
-        InvariantDeviceProfile idp = LauncherAppState.getIDP(mContext);
-        String targetDbName = new DeviceGridState(idp).getDbFile();
+        String targetDbName = new DeviceGridState(mIdp).getDbFile();
         if (TextUtils.equals(targetDbName, mOpenHelper.getDatabaseName())) {
             FileLog.e(TAG, "isCurrentDbSameAsTarget: target db is same as current"
                     + " current db: " + mOpenHelper.getDatabaseName()
@@ -367,7 +374,6 @@
             return;
         }
 
-        InvariantDeviceProfile idp = LauncherAppState.getIDP(mContext);
         DatabaseHelper oldHelper = mOpenHelper;
 
         // We save the existing db's before creating the destination db helper so we know what logic
@@ -376,12 +382,12 @@
                 .filter(dbName -> mContext.getDatabasePath(dbName).exists())
                 .collect(Collectors.toList());
 
-        mOpenHelper = createDatabaseHelper(true, new DeviceGridState(idp).getDbFile());
+        mOpenHelper = createDatabaseHelper(true, new DeviceGridState(mIdp).getDbFile());
         try {
             // This is the current grid we have, given by the mContext
             DeviceGridState srcDeviceState = new DeviceGridState(mContext);
             // This is the state we want to migrate to that is given by the idp
-            DeviceGridState destDeviceState = new DeviceGridState(idp);
+            DeviceGridState destDeviceState = new DeviceGridState(mIdp);
 
             boolean isDestNewDb = !existingDBs.contains(destDeviceState.getDbFile());
             GridSizeMigrationLogic gridSizeMigrationLogic = new GridSizeMigrationLogic();
@@ -404,10 +410,10 @@
             ModelDelegate modelDelegate) {
         if (!migrateGridIfNeeded(modelDelegate)) {
             if (restoreEventLogger != null) {
-                if (LauncherPrefs.get(mContext).get(NO_DB_FILES_RESTORED)) {
+                if (mPrefs.get(NO_DB_FILES_RESTORED)) {
                     restoreEventLogger.logLauncherItemsRestoreFailed(DATA_TYPE_DB_FILE, 1,
                             RestoreError.DATABASE_FILE_NOT_RESTORED);
-                    LauncherPrefs.get(mContext).put(NO_DB_FILES_RESTORED, false);
+                    mPrefs.put(NO_DB_FILES_RESTORED, false);
                     FileLog.d(TAG, "There is no data to migrate: resetting launcher database");
                 } else {
                     restoreEventLogger.logLauncherItemsRestored(DATA_TYPE_DB_FILE, 1);
@@ -416,11 +422,10 @@
             }
             FileLog.d(TAG, "tryMigrateDB: Migration failed: resetting launcher database");
             createEmptyDB();
-            LauncherPrefs.get(mContext).putSync(
-                    getEmptyDbCreatedKey(mOpenHelper.getDatabaseName()).to(true));
+            mPrefs.putSync(getEmptyDbCreatedKey(mOpenHelper.getDatabaseName()).to(true));
 
             // Write the grid state to avoid another migration
-            new DeviceGridState(LauncherAppState.getIDP(mContext)).writeToPrefs(mContext);
+            new DeviceGridState(mIdp).writeToPrefs(mContext);
         } else if (restoreEventLogger != null) {
             restoreEventLogger.logLauncherItemsRestored(DATA_TYPE_DB_FILE, 1);
         }
@@ -434,17 +439,16 @@
      */
     private boolean migrateGridIfNeeded(ModelDelegate modelDelegate) {
         createDbIfNotExists();
-        if (LauncherPrefs.get(mContext).get(getEmptyDbCreatedKey())) {
+        if (mPrefs.get(getEmptyDbCreatedKey())) {
             // If we have already create a new DB, ignore migration
             FileLog.d(TAG, "migrateGridIfNeeded: new DB already created, skipping migration");
             return false;
         }
-        InvariantDeviceProfile idp = LauncherAppState.getIDP(mContext);
-        if (!GridSizeMigrationDBController.needsToMigrate(mContext, idp)) {
+        if (!GridSizeMigrationDBController.needsToMigrate(mContext, mIdp)) {
             FileLog.d(TAG, "migrateGridIfNeeded: no grid migration needed");
             return true;
         }
-        String targetDbName = new DeviceGridState(idp).getDbFile();
+        String targetDbName = new DeviceGridState(mIdp).getDbFile();
         if (TextUtils.equals(targetDbName, mOpenHelper.getDatabaseName())) {
             FileLog.e(TAG, "migrateGridIfNeeded: target db is same as current"
                     + " current db: " + mOpenHelper.getDatabaseName()
@@ -462,7 +466,7 @@
             // This is the current grid we have, given by the mContext
             DeviceGridState srcDeviceState = new DeviceGridState(mContext);
             // This is the state we want to migrate to that is given by the idp
-            DeviceGridState destDeviceState = new DeviceGridState(idp);
+            DeviceGridState destDeviceState = new DeviceGridState(mIdp);
             boolean isDestNewDb = !existingDBs.contains(destDeviceState.getDbFile());
             return GridSizeMigrationDBController.migrateGridIfNeeded(mContext, srcDeviceState,
                     destDeviceState, mOpenHelper, oldHelper.getWritableDatabase(), isDestNewDb,
@@ -611,7 +615,7 @@
     }
 
     private void clearFlagEmptyDbCreated() {
-        LauncherPrefs.get(mContext).removeSync(getEmptyDbCreatedKey());
+        mPrefs.removeSync(getEmptyDbCreatedKey());
     }
 
     /**
@@ -625,7 +629,7 @@
     public synchronized void loadDefaultFavoritesIfNecessary() {
         createDbIfNotExists();
 
-        if (LauncherPrefs.get(mContext).get(getEmptyDbCreatedKey())) {
+        if (mPrefs.get(getEmptyDbCreatedKey())) {
             Log.d(TAG, "loading default workspace");
 
             LauncherWidgetHolder widgetHolder = mOpenHelper.newLauncherWidgetHolder();
@@ -737,10 +741,9 @@
     }
 
     private DefaultLayoutParser getDefaultLayoutParser(LauncherWidgetHolder widgetHolder) {
-        InvariantDeviceProfile idp = LauncherAppState.getIDP(mContext);
-        int defaultLayout = idp.demoModeLayoutId != 0
+        int defaultLayout = mIdp.demoModeLayoutId != 0
                 && mContext.getSystemService(UserManager.class).isDemoUser()
-                ? idp.demoModeLayoutId : idp.defaultLayoutId;
+                ? mIdp.demoModeLayoutId : mIdp.defaultLayoutId;
 
         return new DefaultLayoutParser(mContext, widgetHolder,
                 mOpenHelper, mContext.getResources(), defaultLayout);
@@ -766,6 +769,6 @@
      * Returns the serial number for the provided user
      */
     public long getSerialNumberForUser(UserHandle user) {
-        return UserCache.INSTANCE.get(mContext).getSerialNumberForUser(user);
+        return mUserCache.getSerialNumberForUser(user);
     }
 }
diff --git a/src/com/android/launcher3/model/ModelLauncherCallbacks.kt b/src/com/android/launcher3/model/ModelLauncherCallbacks.kt
index 7ba2dad..8b6c369 100644
--- a/src/com/android/launcher3/model/ModelLauncherCallbacks.kt
+++ b/src/com/android/launcher3/model/ModelLauncherCallbacks.kt
@@ -114,7 +114,7 @@
     override fun onUpdateSessionDisplay(key: PackageUserKey, info: SessionInfo) {
         /** Updates the icons and label of all pending icons for the provided package name. */
         taskExecutor.accept { controller, _, _ ->
-            controller.app.iconCache.updateSessionCache(key, info)
+            controller.iconCache.updateSessionCache(key, info)
         }
         taskExecutor.accept(
             CacheDataUpdatedTask(
@@ -128,7 +128,7 @@
     override fun onInstallSessionCreated(sessionInfo: PackageInstallInfo) {
         if (FeatureFlags.PROMISE_APPS_IN_ALL_APPS.get()) {
             taskExecutor.accept { taskController, _, apps ->
-                apps.addPromiseApp(taskController.app.context, sessionInfo)
+                apps.addPromiseApp(taskController.context, sessionInfo)
                 taskController.bindApplicationsIfNeeded()
             }
         }
diff --git a/src/com/android/launcher3/model/ModelTaskController.kt b/src/com/android/launcher3/model/ModelTaskController.kt
index 5566482..f17ca32 100644
--- a/src/com/android/launcher3/model/ModelTaskController.kt
+++ b/src/com/android/launcher3/model/ModelTaskController.kt
@@ -16,27 +16,34 @@
 
 package com.android.launcher3.model
 
-import com.android.launcher3.LauncherAppState
+import android.content.Context
 import com.android.launcher3.LauncherModel
 import com.android.launcher3.LauncherModel.CallbackTask
 import com.android.launcher3.celllayout.CellPosMapper
+import com.android.launcher3.dagger.ApplicationContext
+import com.android.launcher3.icons.IconCache
 import com.android.launcher3.model.BgDataModel.FixedContainerItems
 import com.android.launcher3.model.data.ItemInfo
+import com.android.launcher3.util.Executors.MAIN_EXECUTOR
 import com.android.launcher3.util.PackageUserKey
 import com.android.launcher3.widget.model.WidgetsListBaseEntriesBuilder
 import java.util.Objects
-import java.util.concurrent.Executor
 import java.util.function.Predicate
+import javax.inject.Inject
 
 /** Class with utility methods and properties for running a LauncherModel Task */
-class ModelTaskController(
-    val app: LauncherAppState,
+class ModelTaskController
+@Inject
+constructor(
+    @ApplicationContext val context: Context,
+    val iconCache: IconCache,
     val dataModel: BgDataModel,
     val allAppsList: AllAppsList,
-    private val model: LauncherModel,
-    private val uiExecutor: Executor,
+    val model: LauncherModel,
 ) {
 
+    private val uiExecutor = MAIN_EXECUTOR
+
     /** Schedules a {@param task} to be executed on the current callbacks. */
     fun scheduleCallbackTask(task: CallbackTask) {
         for (cb in model.callbacks) {
@@ -78,7 +85,7 @@
 
     fun bindUpdatedWidgets(dataModel: BgDataModel) {
         val allWidgets =
-            WidgetsListBaseEntriesBuilder(app.context)
+            WidgetsListBaseEntriesBuilder(context)
                 .build(dataModel.widgetsModel.widgetsByPackageItemForPicker)
         scheduleCallbackTask { it.bindAllWidgets(allWidgets) }
     }
diff --git a/src/com/android/launcher3/model/ModelWriter.java b/src/com/android/launcher3/model/ModelWriter.java
index 0332775..2650e03 100644
--- a/src/com/android/launcher3/model/ModelWriter.java
+++ b/src/com/android/launcher3/model/ModelWriter.java
@@ -16,7 +16,6 @@
 
 package com.android.launcher3.model;
 
-import static com.android.launcher3.LauncherSettings.Favorites.TABLE_NAME;
 import static com.android.launcher3.provider.LauncherDbUtils.itemIdMatch;
 import static com.android.launcher3.util.Executors.MODEL_EXECUTOR;
 
@@ -229,7 +228,7 @@
         }).executeOnModelThread();
     }
 
-    private void notifyItemModified(ItemInfo item) {
+    public void notifyItemModified(ItemInfo item) {
         notifyOtherCallbacks(c -> c.bindItemsModified(Collections.singletonList(item)));
     }
 
@@ -253,7 +252,7 @@
             item.onAddToDatabase(writer);
             writer.put(Favorites._ID, item.id);
 
-            mModel.getModelDbController().insert(Favorites.TABLE_NAME, writer.getValues(mContext));
+            mModel.getModelDbController().insert(writer.getValues(mContext));
             synchronized (mBgDataModel) {
                 checkItemInfoLocked(item.id, item, stackTrace);
                 mBgDataModel.addItem(mContext, item, true);
@@ -292,7 +291,7 @@
         notifyDelete(items);
         enqueueDeleteRunnable(newModelTask(() -> {
             for (ItemInfo item : items) {
-                mModel.getModelDbController().delete(TABLE_NAME, itemIdMatch(item.id), null);
+                mModel.getModelDbController().delete(itemIdMatch(item.id), null);
                 mBgDataModel.removeItem(mContext, item);
                 verifier.verifyModel();
             }
@@ -307,12 +306,12 @@
         notifyDelete(Collections.singleton(info));
 
         enqueueDeleteRunnable(newModelTask(() -> {
-            mModel.getModelDbController().delete(Favorites.TABLE_NAME,
+            mModel.getModelDbController().delete(
                     Favorites.CONTAINER + "=" + info.id, null);
             mBgDataModel.removeItem(mContext, info.getContents());
             info.getContents().clear();
 
-            mModel.getModelDbController().delete(Favorites.TABLE_NAME,
+            mModel.getModelDbController().delete(
                     Favorites._ID + "=" + info.id, null);
             mBgDataModel.removeItem(mContext, info);
             verifier.verifyModel();
@@ -411,7 +410,7 @@
         @Override
         public void runImpl() {
             mModel.getModelDbController().update(
-                    TABLE_NAME, mWriter.get().getValues(mContext), itemIdMatch(mItemId), null);
+                    mWriter.get().getValues(mContext), itemIdMatch(mItemId), null);
             updateItemArrays(mItem, mItemId);
         }
     }
@@ -433,7 +432,7 @@
                     ItemInfo item = mItems.get(i);
                     final int itemId = item.id;
                     mModel.getModelDbController().update(
-                            TABLE_NAME, mValues.get(i), itemIdMatch(itemId), null);
+                            mValues.get(i), itemIdMatch(itemId), null);
                     updateItemArrays(item, itemId);
                 }
                 t.commit();
diff --git a/src/com/android/launcher3/model/PackageInstallStateChangedTask.java b/src/com/android/launcher3/model/PackageInstallStateChangedTask.java
index a216042..a3561ed 100644
--- a/src/com/android/launcher3/model/PackageInstallStateChangedTask.java
+++ b/src/com/android/launcher3/model/PackageInstallStateChangedTask.java
@@ -52,11 +52,11 @@
             try {
                 // For instant apps we do not get package-add. Use setting events to update
                 // any pinned icons.
-                Context context = taskController.getApp().getContext();
+                Context context = taskController.getContext();
                 ApplicationInfo ai = context
                         .getPackageManager().getApplicationInfo(mInstallInfo.packageName, 0);
                 if (InstantAppResolver.newInstance(context).isInstantApp(ai)) {
-                    taskController.getApp().getModel().newModelCallbacks()
+                    taskController.getModel().newModelCallbacks()
                             .onPackageAdded(ai.packageName, mInstallInfo.user);
                 }
             } catch (PackageManager.NameNotFoundException e) {
diff --git a/src/com/android/launcher3/model/PackageUpdatedTask.java b/src/com/android/launcher3/model/PackageUpdatedTask.java
index 3cdb250..04f3faa 100644
--- a/src/com/android/launcher3/model/PackageUpdatedTask.java
+++ b/src/com/android/launcher3/model/PackageUpdatedTask.java
@@ -38,7 +38,6 @@
 import androidx.annotation.NonNull;
 
 import com.android.launcher3.Flags;
-import com.android.launcher3.LauncherAppState;
 import com.android.launcher3.LauncherModel.ModelUpdateTask;
 import com.android.launcher3.LauncherSettings.Favorites;
 import com.android.launcher3.config.FeatureFlags;
@@ -106,9 +105,8 @@
     @Override
     public void execute(@NonNull ModelTaskController taskController, @NonNull BgDataModel dataModel,
             @NonNull AllAppsList appsList) {
-        final LauncherAppState app = taskController.getApp();
-        final Context context = app.getContext();
-        final IconCache iconCache = app.getIconCache();
+        final Context context = taskController.getContext();
+        final IconCache iconCache = taskController.getIconCache();
 
         final String[] packages = mPackages;
         final int packageCount = packages.length;
@@ -433,7 +431,7 @@
             // Load widgets for the new package. Changes due to app updates are handled through
             // AppWidgetHost events, this is just to initialize the long-press options.
             for (int i = 0; i < packageCount; i++) {
-                dataModel.widgetsModel.update(app, new PackageUserKey(packages[i], mUser));
+                dataModel.widgetsModel.update(new PackageUserKey(packages[i], mUser));
             }
             taskController.bindUpdatedWidgets(dataModel);
         }
diff --git a/src/com/android/launcher3/model/SdCardAvailableReceiver.java b/src/com/android/launcher3/model/SdCardAvailableReceiver.java
index 9e3f0e1..9ae8092 100644
--- a/src/com/android/launcher3/model/SdCardAvailableReceiver.java
+++ b/src/com/android/launcher3/model/SdCardAvailableReceiver.java
@@ -22,7 +22,6 @@
 import android.content.pm.LauncherApps;
 import android.os.UserHandle;
 
-import com.android.launcher3.LauncherAppState;
 import com.android.launcher3.LauncherModel;
 import com.android.launcher3.util.ApplicationInfoWrapper;
 import com.android.launcher3.util.PackageUserKey;
@@ -43,9 +42,10 @@
     private final Context mContext;
     private final Set<PackageUserKey> mPackages;
 
-    public SdCardAvailableReceiver(LauncherAppState app, Set<PackageUserKey> packages) {
-        mModel = app.getModel();
-        mContext = app.getContext();
+    public SdCardAvailableReceiver(
+            Context context, LauncherModel model, Set<PackageUserKey> packages) {
+        mContext = context;
+        mModel = model;
         mPackages = packages;
     }
 
diff --git a/src/com/android/launcher3/model/SessionFailureTask.kt b/src/com/android/launcher3/model/SessionFailureTask.kt
index 8baf568..6ed5178 100644
--- a/src/com/android/launcher3/model/SessionFailureTask.kt
+++ b/src/com/android/launcher3/model/SessionFailureTask.kt
@@ -33,9 +33,9 @@
         dataModel: BgDataModel,
         apps: AllAppsList,
     ) {
-        val iconCache = taskController.app.iconCache
+        val iconCache = taskController.iconCache
         val isAppArchived =
-            ApplicationInfoWrapper(taskController.app.context, packageName, user).isArchived()
+            ApplicationInfoWrapper(taskController.context, packageName, user).isArchived()
         synchronized(dataModel) {
             if (isAppArchived) {
                 val updatedItems = mutableListOf<WorkspaceItemInfo>()
diff --git a/src/com/android/launcher3/model/ShortcutsChangedTask.kt b/src/com/android/launcher3/model/ShortcutsChangedTask.kt
index 56e9e43..d6759e2 100644
--- a/src/com/android/launcher3/model/ShortcutsChangedTask.kt
+++ b/src/com/android/launcher3/model/ShortcutsChangedTask.kt
@@ -40,8 +40,7 @@
         dataModel: BgDataModel,
         apps: AllAppsList,
     ) {
-        val app = taskController.app
-        val context = app.context
+        val context = taskController.context
         // Find WorkspaceItemInfo's that have changed on the workspace.
         val matchingWorkspaceItems = ArrayList<WorkspaceItemInfo>()
 
@@ -88,7 +87,7 @@
                     .filter { itemInfo: WorkspaceItemInfo -> shortcutId == itemInfo.deepShortcutId }
                     .forEach { workspaceItemInfo: WorkspaceItemInfo ->
                         workspaceItemInfo.updateFromDeepShortcutInfo(fullDetails, context)
-                        app.iconCache.getShortcutIcon(
+                        taskController.iconCache.getShortcutIcon(
                             workspaceItemInfo,
                             CacheableShortcutInfo(fullDetails, infoWrapper),
                         )
diff --git a/src/com/android/launcher3/model/UserLockStateChangedTask.java b/src/com/android/launcher3/model/UserLockStateChangedTask.java
index 3dc5ff3..4d28ccb 100644
--- a/src/com/android/launcher3/model/UserLockStateChangedTask.java
+++ b/src/com/android/launcher3/model/UserLockStateChangedTask.java
@@ -23,7 +23,6 @@
 
 import androidx.annotation.NonNull;
 
-import com.android.launcher3.LauncherAppState;
 import com.android.launcher3.LauncherModel.ModelUpdateTask;
 import com.android.launcher3.LauncherSettings;
 import com.android.launcher3.model.data.WorkspaceItemInfo;
@@ -55,8 +54,7 @@
     @Override
     public void execute(@NonNull ModelTaskController taskController, @NonNull BgDataModel dataModel,
             @NonNull AllAppsList apps) {
-        LauncherAppState app = taskController.getApp();
-        Context context = app.getContext();
+        Context context = taskController.getContext();
 
         HashMap<ShortcutKey, ShortcutInfo> pinnedShortcuts = new HashMap<>();
         if (mIsUserUnlocked) {
@@ -92,7 +90,7 @@
                         }
                         si.runtimeStatusFlags &= ~FLAG_DISABLED_LOCKED_USER;
                         si.updateFromDeepShortcutInfo(shortcut, context);
-                        app.getIconCache().getShortcutIcon(si, shortcut);
+                        taskController.getIconCache().getShortcutIcon(si, shortcut);
                     } else {
                         si.runtimeStatusFlags |= FLAG_DISABLED_LOCKED_USER;
                     }
diff --git a/src/com/android/launcher3/model/WidgetsModel.java b/src/com/android/launcher3/model/WidgetsModel.java
index 52b142d..f2144c0 100644
--- a/src/com/android/launcher3/model/WidgetsModel.java
+++ b/src/com/android/launcher3/model/WidgetsModel.java
@@ -27,6 +27,7 @@
 import com.android.launcher3.LauncherAppState;
 import com.android.launcher3.Utilities;
 import com.android.launcher3.config.FeatureFlags;
+import com.android.launcher3.dagger.ApplicationContext;
 import com.android.launcher3.icons.IconCache;
 import com.android.launcher3.icons.cache.CachedObject;
 import com.android.launcher3.model.data.PackageItemInfo;
@@ -54,6 +55,8 @@
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
+import javax.inject.Inject;
+
 /**
  * Widgets data model that is used by the adapters of the widget views and controllers.
  *
@@ -68,6 +71,29 @@
     private final Map<PackageItemInfo, List<WidgetItem>> mWidgetsByPackageItem = new HashMap<>();
     @Nullable private WidgetValidityCheckForPicker mWidgetValidityCheckForPicker = null;
 
+    private final Context mContext;
+    private final InvariantDeviceProfile mIdp;
+    private final IconCache mIconCache;
+    private final AppFilter mAppFilter;
+
+    @Inject
+    public WidgetsModel(
+            @ApplicationContext Context context,
+            InvariantDeviceProfile idp,
+            IconCache iconCache,
+            AppFilter appFilter) {
+        mContext = context;
+        mIdp = idp;
+        mIconCache = iconCache;
+        mAppFilter = appFilter;
+    }
+
+    public WidgetsModel(Context context) {
+        this(context,
+                LauncherAppState.getIDP(context),
+                LauncherAppState.getInstance(context).getIconCache(), new AppFilter(context));
+    }
+
     /**
      * Returns all widgets keyed by their component key.
      */
@@ -128,36 +154,33 @@
      * @param packageUser If null, all widgets and shortcuts are updated and returned, otherwise
      *                    only widgets and shortcuts associated with the package/user are.
      */
-    public List<CachedObject> update(
-            LauncherAppState app, @Nullable PackageUserKey packageUser) {
+    public List<CachedObject> update(@Nullable PackageUserKey packageUser) {
         if (!WIDGETS_ENABLED) {
             return new ArrayList<>();
         }
         Preconditions.assertWorkerThread();
 
-        Context context = app.getContext();
         final ArrayList<WidgetItem> widgetsAndShortcuts = new ArrayList<>();
         List<CachedObject> updatedItems = new ArrayList<>();
         try {
-            InvariantDeviceProfile idp = app.getInvariantDeviceProfile();
             // Widgets
-            WidgetManagerHelper widgetManager = new WidgetManagerHelper(context);
+            WidgetManagerHelper widgetManager = new WidgetManagerHelper(mContext);
             for (AppWidgetProviderInfo widgetInfo : widgetManager.getAllProviders(packageUser)) {
                 LauncherAppWidgetProviderInfo launcherWidgetInfo =
-                        LauncherAppWidgetProviderInfo.fromProviderInfo(context, widgetInfo);
+                        LauncherAppWidgetProviderInfo.fromProviderInfo(mContext, widgetInfo);
 
                 widgetsAndShortcuts.add(new WidgetItem(
-                        launcherWidgetInfo, idp, app.getIconCache(), app.getContext()));
+                        launcherWidgetInfo, mIdp, mIconCache, mContext));
                 updatedItems.add(launcherWidgetInfo);
             }
 
             // Shortcuts
             for (ShortcutConfigActivityInfo info :
-                    queryList(context, packageUser)) {
-                widgetsAndShortcuts.add(new WidgetItem(info, app.getIconCache()));
+                    queryList(mContext, packageUser)) {
+                widgetsAndShortcuts.add(new WidgetItem(info, mIconCache));
                 updatedItems.add(info);
             }
-            setWidgetsAndShortcuts(widgetsAndShortcuts, app, packageUser);
+            setWidgetsAndShortcuts(widgetsAndShortcuts, packageUser);
         } catch (Exception e) {
             if (!FeatureFlags.IS_STUDIO_BUILD && Utilities.isBinderSizeError(e)) {
                 // the returned value may be incomplete and will not be refreshed until the next
@@ -172,14 +195,14 @@
         return updatedItems;
     }
 
-    private synchronized void setWidgetsAndShortcuts(ArrayList<WidgetItem> rawWidgetsShortcuts,
-            LauncherAppState app, @Nullable PackageUserKey packageUser) {
+    private synchronized void setWidgetsAndShortcuts(
+            ArrayList<WidgetItem> rawWidgetsShortcuts, @Nullable PackageUserKey packageUser) {
         if (DEBUG) {
             Log.d(TAG, "addWidgetsAndShortcuts, widgetsShortcuts#=" + rawWidgetsShortcuts.size());
         }
 
         // Refresh the validity checker with latest app state.
-        mWidgetValidityCheckForPicker = new WidgetValidityCheckForPicker(app);
+        mWidgetValidityCheckForPicker = new WidgetValidityCheckForPicker(mIdp, mAppFilter);
 
         // Temporary cache for {@link PackageItemInfos} to avoid having to go through
         // {@link mPackageItemInfos} to locate the key to be used for {@link #mWidgetsList}
@@ -196,19 +219,17 @@
         // add and update.
         mWidgetsByPackageItem.putAll(rawWidgetsShortcuts.stream()
                 .filter(new WidgetFlagCheck())
-                .flatMap(widgetItem -> getPackageUserKeys(app.getContext(), widgetItem).stream()
+                .flatMap(widgetItem -> getPackageUserKeys(mContext, widgetItem).stream()
                         .map(key -> new Pair<>(packageItemInfoCache.getOrCreate(key), widgetItem)))
                 .collect(groupingBy(pair -> pair.first, mapping(pair -> pair.second, toList()))));
 
         // Update each package entry
-        IconCache iconCache = app.getIconCache();
         for (PackageItemInfo p : packageItemInfoCache.values()) {
-            iconCache.getTitleAndIconForApp(p, DEFAULT_LOOKUP_FLAG.withUseLowRes());
+            mIconCache.getTitleAndIconForApp(p, DEFAULT_LOOKUP_FLAG.withUseLowRes());
         }
     }
 
-    public void onPackageIconsUpdated(Set<String> packageNames, UserHandle user,
-            LauncherAppState app) {
+    public void onPackageIconsUpdated(Set<String> packageNames, UserHandle user) {
         if (!WIDGETS_ENABLED) {
             return;
         }
@@ -220,11 +241,10 @@
                     WidgetItem item = items.get(i);
                     if (item.user.equals(user)) {
                         if (item.activityInfo != null) {
-                            items.set(i, new WidgetItem(item.activityInfo, app.getIconCache()));
+                            items.set(i, new WidgetItem(item.activityInfo, mIconCache));
                         } else {
-                            items.set(i, new WidgetItem(item.widgetInfo,
-                                    app.getInvariantDeviceProfile(), app.getIconCache(),
-                                    app.getContext()));
+                            items.set(i, new WidgetItem(
+                                    item.widgetInfo, mIdp, mIconCache, mContext));
                         }
                     }
                 }
@@ -277,9 +297,9 @@
         private final InvariantDeviceProfile mIdp;
         private final AppFilter mAppFilter;
 
-        WidgetValidityCheckForPicker(LauncherAppState app) {
-            mIdp = app.getInvariantDeviceProfile();
-            mAppFilter = new AppFilter(app.getContext());
+        WidgetValidityCheckForPicker(InvariantDeviceProfile idp, AppFilter appFilter) {
+            mIdp = idp;
+            mAppFilter = appFilter;
         }
 
         @Override
diff --git a/src/com/android/launcher3/model/WorkspaceItemProcessor.kt b/src/com/android/launcher3/model/WorkspaceItemProcessor.kt
index 99f2837..7b8f218 100644
--- a/src/com/android/launcher3/model/WorkspaceItemProcessor.kt
+++ b/src/com/android/launcher3/model/WorkspaceItemProcessor.kt
@@ -18,6 +18,7 @@
 import android.annotation.SuppressLint
 import android.appwidget.AppWidgetProviderInfo
 import android.content.ComponentName
+import android.content.Context
 import android.content.Intent
 import android.content.pm.LauncherApps
 import android.content.pm.LauncherApps.ShortcutQuery
@@ -29,10 +30,10 @@
 import android.util.LongSparseArray
 import com.android.launcher3.Flags
 import com.android.launcher3.InvariantDeviceProfile
-import com.android.launcher3.LauncherAppState
 import com.android.launcher3.LauncherSettings.Favorites
 import com.android.launcher3.backuprestore.LauncherRestoreEventLogger.RestoreError
 import com.android.launcher3.icons.CacheableShortcutInfo
+import com.android.launcher3.icons.IconCache
 import com.android.launcher3.icons.cache.CacheLookupFlag.Companion.DEFAULT_LOOKUP_FLAG
 import com.android.launcher3.logging.FileLog
 import com.android.launcher3.model.data.AppInfo
@@ -70,7 +71,10 @@
     private val launcherApps: LauncherApps,
     private val pendingPackages: MutableSet<PackageUserKey>,
     private val shortcutKeyToPinnedShortcuts: Map<ShortcutKey, ShortcutInfo>,
-    private val app: LauncherAppState,
+    private val context: Context,
+    private val idp: InvariantDeviceProfile,
+    private val iconCache: IconCache,
+    private val isSafeMode: Boolean,
     private val bgDataModel: BgDataModel,
     private val widgetProvidersMap: MutableMap<ComponentKey, AppWidgetProviderInfo?>,
     private val installingPkgs: HashMap<PackageUserKey, PackageInstaller.SessionInfo>,
@@ -82,9 +86,7 @@
     private val allDeepShortcuts: MutableList<CacheableShortcutInfo>,
 ) {
 
-    private val isSafeMode = app.isSafeModeEnabled
     private val tempPackageKey = PackageUserKey(null, null)
-    private val iconCache = app.iconCache
 
     /**
      * This is the entry point for processing 1 workspace item. This method is like the midfielder
@@ -159,7 +161,7 @@
             )
             return
         }
-        val appInfoWrapper = ApplicationInfoWrapper(app.context, targetPkg, c.user)
+        val appInfoWrapper = ApplicationInfoWrapper(context, targetPkg, c.user)
         var validTarget = launcherApps.isPackageEnabled(targetPkg, c.user)
 
         // If it's a deep shortcut, we'll use pinned shortcuts to restore it
@@ -306,7 +308,7 @@
                         )
                         return
                     }
-                    info = WorkspaceItemInfo(pinnedShortcut, app.context)
+                    info = WorkspaceItemInfo(pinnedShortcut, context)
                     // If the pinned deep shortcut is no longer published,
                     // use the last saved icon instead of the default.
                     val csi = CacheableShortcutInfo(pinnedShortcut, appInfoWrapper)
@@ -369,7 +371,7 @@
                     info,
                     activityInfo,
                     userCache.getUserInfo(c.user),
-                    ApiWrapper.INSTANCE[app.context],
+                    ApiWrapper.INSTANCE[context],
                     pmHelper,
                 )
             }
@@ -529,7 +531,7 @@
                         (si == null) &&
                         (lapi == null) &&
                         !(Flags.enableSupportForArchiving() &&
-                            ApplicationInfoWrapper(app.context, component.packageName, c.user)
+                            ApplicationInfoWrapper(context, component.packageName, c.user)
                                 .isArchived())
                 ) {
                     // Restore never started
@@ -553,7 +555,7 @@
                     if (si == null) 0 else (si.getProgress() * 100).toInt()
                 appWidgetInfo.pendingItemInfo =
                     WidgetsModel.newPendingItemInfo(
-                        app.context,
+                        context,
                         appWidgetInfo.providerName,
                         appWidgetInfo.user,
                     )
@@ -563,7 +565,7 @@
                 WidgetSizes.updateWidgetSizeRangesAsync(
                     appWidgetInfo.appWidgetId,
                     lapi,
-                    app.context,
+                    context,
                     appWidgetInfo.spanX,
                     appWidgetInfo.spanY,
                 )
@@ -586,7 +588,7 @@
                         " appWidgetId: ${c.appWidgetId}," +
                         " component=${component}",
                 )
-                logWidgetInfo(app.invariantDeviceProfile, lapi)
+                logWidgetInfo(idp, lapi)
             }
         }
         c.checkAndAddItem(appWidgetInfo, bgDataModel, memoryLogger)
diff --git a/src/com/android/launcher3/model/WorkspaceItemSpaceFinder.java b/src/com/android/launcher3/model/WorkspaceItemSpaceFinder.java
index 1a6d178..17f1615 100644
--- a/src/com/android/launcher3/model/WorkspaceItemSpaceFinder.java
+++ b/src/com/android/launcher3/model/WorkspaceItemSpaceFinder.java
@@ -21,7 +21,7 @@
 import android.util.LongSparseArray;
 
 import com.android.launcher3.InvariantDeviceProfile;
-import com.android.launcher3.LauncherAppState;
+import com.android.launcher3.LauncherModel;
 import com.android.launcher3.LauncherSettings;
 import com.android.launcher3.config.FeatureFlags;
 import com.android.launcher3.model.data.ItemInfo;
@@ -31,23 +31,37 @@
 
 import java.util.ArrayList;
 
+import javax.inject.Inject;
+
 /**
  * Utility class to help find space for new workspace items
  */
 public class WorkspaceItemSpaceFinder {
 
+    private BgDataModel mDataModel;
+    private InvariantDeviceProfile mIDP;
+    private LauncherModel mModel;
+
+    @Inject
+    WorkspaceItemSpaceFinder(
+            BgDataModel dataModel, InvariantDeviceProfile idp, LauncherModel model) {
+        mDataModel = dataModel;
+        mIDP = idp;
+        mModel = model;
+    }
+
     /**
      * Find a position on the screen for the given size or adds a new screen.
      *
      * @return screenId and the coordinates for the item in an int array of size 3.
      */
-    public int[] findSpaceForItem(LauncherAppState app, BgDataModel dataModel,
+    public int[] findSpaceForItem(
             IntArray workspaceScreens, IntArray addedWorkspaceScreensFinal, int spanX, int spanY) {
         LongSparseArray<ArrayList<ItemInfo>> screenItems = new LongSparseArray<>();
 
         // Use sBgItemsIdMap as all the items are already loaded.
-        synchronized (dataModel) {
-            for (ItemInfo info : dataModel.itemsIdMap) {
+        synchronized (mDataModel) {
+            for (ItemInfo info : mDataModel.itemsIdMap) {
                 if (info.container == LauncherSettings.Favorites.CONTAINER_DESKTOP) {
                     ArrayList<ItemInfo> items = screenItems.get(info.screenId);
                     if (items == null) {
@@ -75,7 +89,7 @@
         for (int screen = 0; screen < screenCount; screen++) {
             screenId = workspaceScreens.get(screen);
             if (!screensToExclude.contains(screenId) && findNextAvailableIconSpaceInScreen(
-                    app, screenItems.get(screenId), coordinates, spanX, spanY)) {
+                    screenItems.get(screenId), coordinates, spanX, spanY)) {
                 // We found a space for it
                 found = true;
                 break;
@@ -84,7 +98,7 @@
 
         if (!found) {
             // Still no position found. Add a new screen to the end.
-            screenId = app.getModel().getModelDbController().getNewScreenId();
+            screenId = mModel.getModelDbController().getNewScreenId();
 
             // Save the screen id for binding in the workspace
             workspaceScreens.add(screenId);
@@ -92,7 +106,7 @@
 
             // If we still can't find an empty space, then God help us all!!!
             if (!findNextAvailableIconSpaceInScreen(
-                    app, screenItems.get(screenId), coordinates, spanX, spanY)) {
+                    screenItems.get(screenId), coordinates, spanX, spanY)) {
                 throw new RuntimeException("Can't find space to add the item");
             }
         }
@@ -100,11 +114,8 @@
     }
 
     private boolean findNextAvailableIconSpaceInScreen(
-            LauncherAppState app, ArrayList<ItemInfo> occupiedPos,
-            int[] xy, int spanX, int spanY) {
-        InvariantDeviceProfile profile = app.getInvariantDeviceProfile();
-
-        GridOccupancy occupied = new GridOccupancy(profile.numColumns, profile.numRows);
+            ArrayList<ItemInfo> occupiedPos, int[] xy, int spanX, int spanY) {
+        GridOccupancy occupied = new GridOccupancy(mIDP.numColumns, mIDP.numRows);
         if (occupiedPos != null) {
             for (ItemInfo r : occupiedPos) {
                 occupied.markCells(r, true);
diff --git a/src/com/android/launcher3/model/data/FolderInfo.java b/src/com/android/launcher3/model/data/FolderInfo.java
index 9656ac1..4c792a7 100644
--- a/src/com/android/launcher3/model/data/FolderInfo.java
+++ b/src/com/android/launcher3/model/data/FolderInfo.java
@@ -20,6 +20,9 @@
 
 import static androidx.core.util.Preconditions.checkNotNull;
 
+import static com.android.launcher3.LauncherSettings.Favorites.ITEM_TYPE_APPLICATION;
+import static com.android.launcher3.LauncherSettings.Favorites.ITEM_TYPE_APP_PAIR;
+import static com.android.launcher3.LauncherSettings.Favorites.ITEM_TYPE_DEEP_SHORTCUT;
 import static com.android.launcher3.logger.LauncherAtom.Attribute.EMPTY_LABEL;
 import static com.android.launcher3.logger.LauncherAtom.Attribute.MANUAL_LABEL;
 import static com.android.launcher3.logger.LauncherAtom.Attribute.SUGGESTED_LABEL;
@@ -30,8 +33,6 @@
 import androidx.annotation.Nullable;
 
 import com.android.launcher3.LauncherSettings;
-import com.android.launcher3.Utilities;
-import com.android.launcher3.folder.Folder;
 import com.android.launcher3.folder.FolderNameInfos;
 import com.android.launcher3.logger.LauncherAtom;
 import com.android.launcher3.logger.LauncherAtom.Attribute;
@@ -42,8 +43,6 @@
 import com.android.launcher3.util.ContentWriter;
 
 import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
 import java.util.OptionalInt;
 import java.util.stream.IntStream;
 
@@ -52,18 +51,6 @@
  */
 public class FolderInfo extends CollectionInfo {
 
-    public static final int NO_FLAGS = 0x00000000;
-
-    /**
-     * The folder is locked in sorted mode
-     */
-    public static final int FLAG_ITEMS_SORTED = 0x00000001;
-
-    /**
-     * It is a work folder
-     */
-    public static final int FLAG_WORK_FOLDER = 0x00000002;
-
     /**
      * The multi-page animation has run for this folder
      */
@@ -95,8 +82,6 @@
         }
     }
 
-    public static final String EXTRA_FOLDER_SUGGESTIONS = "suggest";
-
     public int options;
 
     public FolderNameInfos suggestedFolderNames;
@@ -106,61 +91,16 @@
      */
     private final ArrayList<ItemInfo> contents = new ArrayList<>();
 
-    private ArrayList<FolderListener> mListeners = new ArrayList<>();
-
     public FolderInfo() {
         itemType = LauncherSettings.Favorites.ITEM_TYPE_FOLDER;
     }
 
-    /** Adds a app or shortcut to the contents ArrayList without animation. */
     @Override
     public void add(@NonNull ItemInfo item) {
-        add(item, false /* animate */);
-    }
-
-    /**
-     * Add an app or shortcut
-     *
-     * @param item
-     */
-    public void add(ItemInfo item, boolean animate) {
-        add(item, getContents().size(), animate);
-    }
-
-    /**
-     * Add an app or shortcut for a specified rank.
-     */
-    public void add(ItemInfo item, int rank, boolean animate) {
-        if (!Folder.willAccept(item)) {
+        if (!willAcceptItemType(item.itemType)) {
             throw new RuntimeException("tried to add an illegal type into a folder");
         }
-
-        rank = Utilities.boundToRange(rank, 0, getContents().size());
-        getContents().add(rank, item);
-        for (int i = 0; i < mListeners.size(); i++) {
-            mListeners.get(i).onAdd(item, rank);
-        }
-        itemsChanged(animate);
-    }
-
-    /**
-     * Remove an app or shortcut. Does not change the DB.
-     *
-     * @param item
-     */
-    public void remove(ItemInfo item, boolean animate) {
-        removeAll(Collections.singletonList(item), animate);
-    }
-
-    /**
-     * Remove all matching app or shortcut. Does not change the DB.
-     */
-    public void removeAll(List<ItemInfo> items, boolean animate) {
-        contents.removeAll(items);
-        for (int i = 0; i < mListeners.size(); i++) {
-            mListeners.get(i).onRemove(items);
-        }
-        itemsChanged(animate);
+        getContents().add(item);
     }
 
     /**
@@ -197,28 +137,6 @@
         writer.put(LauncherSettings.Favorites.OPTIONS, options);
     }
 
-    public void addListener(FolderListener listener) {
-        mListeners.add(listener);
-    }
-
-    public void removeListener(FolderListener listener) {
-        mListeners.remove(listener);
-    }
-
-    public void itemsChanged(boolean animate) {
-        for (int i = 0; i < mListeners.size(); i++) {
-            mListeners.get(i).onItemsChanged(animate);
-        }
-    }
-
-    public interface FolderListener {
-        void onAdd(ItemInfo item, int rank);
-        void onRemove(List<ItemInfo> item);
-        void onItemsChanged(boolean animate);
-        void onTitleChanged(CharSequence title);
-
-    }
-
     public boolean hasOption(int optionFlag) {
         return (options & optionFlag) != 0;
     }
@@ -261,7 +179,6 @@
                 .build();
     }
 
-    @Override
     public void setTitle(@Nullable CharSequence title, ModelWriter modelWriter) {
         // Updating label from null to empty is considered as false touch.
         // Retaining null title(ie., UNLABELED state) allows auto-labeling when new items added.
@@ -289,10 +206,6 @@
         if (modelWriter != null) {
             modelWriter.updateItemInDatabase(this);
         }
-
-        for (int i = 0; i < mListeners.size(); i++) {
-            mListeners.get(i).onTitleChanged(title);
-        }
     }
 
     /**
@@ -401,4 +314,13 @@
         }
         return LauncherAtom.ToState.TO_STATE_UNSPECIFIED;
     }
+
+    /**
+     * Checks if {@code itemType} is a type that can be placed in folders.
+     */
+    public static boolean willAcceptItemType(int itemType) {
+        return itemType == ITEM_TYPE_APPLICATION
+                || itemType == ITEM_TYPE_DEEP_SHORTCUT
+                || itemType == ITEM_TYPE_APP_PAIR;
+    }
 }
diff --git a/src/com/android/launcher3/model/data/ItemInfo.java b/src/com/android/launcher3/model/data/ItemInfo.java
index 588e759..ad7696c 100644
--- a/src/com/android/launcher3/model/data/ItemInfo.java
+++ b/src/com/android/launcher3/model/data/ItemInfo.java
@@ -61,7 +61,6 @@
 import com.android.launcher3.logger.LauncherAtom.TaskSwitcherContainer;
 import com.android.launcher3.logger.LauncherAtom.WallpapersContainer;
 import com.android.launcher3.logger.LauncherAtomExtensions.ExtendedContainers;
-import com.android.launcher3.model.ModelWriter;
 import com.android.launcher3.pm.UserCache;
 import com.android.launcher3.util.ComponentKey;
 import com.android.launcher3.util.ContentWriter;
@@ -536,14 +535,6 @@
     }
 
     /**
-     * Sets the title of the item and writes to DB model if needed.
-     */
-    public void setTitle(@Nullable final CharSequence title,
-            @Nullable final ModelWriter modelWriter) {
-        this.title = title;
-    }
-
-    /**
      * Returns a string ID that is stable for a user session, but may not be persisted
      */
     @Nullable
diff --git a/src/com/android/launcher3/pageindicators/PageIndicator.java b/src/com/android/launcher3/pageindicators/PageIndicator.java
index 0640bf3..a6f76c4 100644
--- a/src/com/android/launcher3/pageindicators/PageIndicator.java
+++ b/src/com/android/launcher3/pageindicators/PageIndicator.java
@@ -15,6 +15,8 @@
  */
 package com.android.launcher3.pageindicators;
 
+import java.util.function.Consumer;
+
 /**
  * Base class for a page indicator.
  */
@@ -27,6 +29,14 @@
     void setMarkersCount(int numMarkers);
 
     /**
+     * This is only going to be used by the FolderPagedView's PageIndicator. A refactor is planned
+     * to separate the two purposes of this class, but in the meantime, this indicator will serve to
+     * let the folder snap to the page of its click, and also tell the PageIndicator not to draw
+     * arrows if the click listener is null (at least until after this is refactored).
+     */
+    void setArrowClickListener(Consumer<Direction> listener);
+
+    /**
      * Sets a flag indicating whether to pause scroll.
      * <p>Should be set to {@code true} while the screen is binding or new data is being applied,
      * and to {@code false} once done. This prevents animation conflicts due to scrolling during
diff --git a/src/com/android/launcher3/pageindicators/PageIndicatorArrowClickListener.kt b/src/com/android/launcher3/pageindicators/PageIndicatorArrowClickListener.kt
new file mode 100644
index 0000000..970d210
--- /dev/null
+++ b/src/com/android/launcher3/pageindicators/PageIndicatorArrowClickListener.kt
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.launcher3.pageindicators
+
+interface PageIndicatorArrowClickListener {
+    fun onArrowClick(direction: Direction)
+}
+
+enum class Direction {
+    END,
+    START,
+}
diff --git a/src/com/android/launcher3/pageindicators/PageIndicatorDots.java b/src/com/android/launcher3/pageindicators/PageIndicatorDots.java
index 37f5189..384f876 100644
--- a/src/com/android/launcher3/pageindicators/PageIndicatorDots.java
+++ b/src/com/android/launcher3/pageindicators/PageIndicatorDots.java
@@ -32,11 +32,13 @@
 import android.graphics.Paint.Style;
 import android.graphics.Rect;
 import android.graphics.RectF;
+import android.graphics.drawable.VectorDrawable;
 import android.os.Handler;
 import android.os.Looper;
 import android.util.AttributeSet;
 import android.util.FloatProperty;
 import android.util.IntProperty;
+import android.view.MotionEvent;
 import android.view.View;
 import android.view.ViewConfiguration;
 import android.view.ViewOutlineProvider;
@@ -51,9 +53,14 @@
 import com.android.launcher3.Utilities;
 import com.android.launcher3.util.Themes;
 
+import java.util.function.Consumer;
+
 /**
  * {@link PageIndicator} which shows dots per page. The active page is shown with the current
  * accent color.
+ * <p>
+ * TODO(b/402258632): Split PageIndicatorDots into 2 different classes: FolderPageIndicator &
+ * WorkspacePageIndicator. A lot of the functionality in this class is only used by one UI purpose.
  */
 public class PageIndicatorDots extends View implements Insettable, PageIndicator {
 
@@ -68,6 +75,12 @@
     private static final int ENTER_ANIMATION_STAGGERED_DELAY = 150;
     private static final int ENTER_ANIMATION_DURATION = 400;
 
+    private static final int LARGE_HEIGHT_MULTIPLIER = 12;
+    private static final int SMALL_HEIGHT_MULTIPLIER = 4;
+    private static final int LARGE_WIDTH_MULTIPLIER = 5;
+    private static final int SMALL_WIDTH_MULTIPLIER = 3;
+    private static final float ARROW_TOUCH_BOX_FACTOR = 5f;
+
     private static final int PAGE_INDICATOR_ALPHA = 255;
     private static final int DOT_ALPHA = 128;
     private static final float DOT_ALPHA_FRACTION = 0.5f;
@@ -75,12 +88,14 @@
     private static final int VISIBLE_ALPHA = 255;
     private static final int INVISIBLE_ALPHA = 0;
     private Paint mPaginationPaint;
+    private Consumer<Direction> mOnArrowClickListener;
 
     // This value approximately overshoots to 1.5 times the original size.
     private static final float ENTER_ANIMATION_OVERSHOOT_TENSION = 4.9f;
 
     // This is used to optimize the onDraw method by not constructing a new RectF each draw.
     private static final RectF sTempRect = new RectF();
+    private static final RectF sLastActiveRect = new RectF();
 
     private static final FloatProperty<PageIndicatorDots> CURRENT_POSITION =
             new FloatProperty<PageIndicatorDots>("current_position") {
@@ -99,23 +114,27 @@
 
     private static final IntProperty<PageIndicatorDots> PAGINATION_ALPHA =
             new IntProperty<PageIndicatorDots>("pagination_alpha") {
-        @Override
-        public Integer get(PageIndicatorDots obj) {
-            return obj.mPaginationPaint.getAlpha();
-        }
+                @Override
+                public Integer get(PageIndicatorDots obj) {
+                    return obj.mPaginationPaint.getAlpha();
+                }
 
-        @Override
-        public void setValue(PageIndicatorDots obj, int alpha) {
-            obj.mPaginationPaint.setAlpha(alpha);
-            obj.invalidate();
-        }
-    };
+                @Override
+                public void setValue(PageIndicatorDots obj, int alpha) {
+                    obj.mPaginationPaint.setAlpha(alpha);
+                    obj.invalidate();
+                }
+            };
 
     private final Handler mDelayedPaginationFadeHandler = new Handler(Looper.getMainLooper());
     private final float mDotRadius;
     private final float mGapWidth;
     private final float mCircleGap;
     private final boolean mIsRtl;
+    private final VectorDrawable mArrowRight;
+    private final VectorDrawable mArrowLeft;
+    private final Rect mArrowRightBounds = new Rect();
+    private final Rect mArrowLeftBounds = new Rect();
 
     private int mNumPages;
     private int mActivePage;
@@ -167,6 +186,8 @@
                 : DOT_GAP_FACTOR * mDotRadius;
         setOutlineProvider(new MyOutlineProver());
         mIsRtl = Utilities.isRtl(getResources());
+        mArrowRight = (VectorDrawable) getResources().getDrawable(R.drawable.ic_chevron_end);
+        mArrowLeft = (VectorDrawable) getResources().getDrawable(R.drawable.ic_chevron_start);
     }
 
     @Override
@@ -405,6 +426,11 @@
     }
 
     @Override
+    public void setArrowClickListener(Consumer<Direction> listener) {
+        mOnArrowClickListener = listener;
+    }
+
+    @Override
     public void setPauseScroll(boolean pause, boolean isTwoPanels) {
         mIsTwoPanels = isTwoPanels;
 
@@ -419,11 +445,16 @@
     @Override
     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
         // TODO(b/394355070): Verify Folder Entry Animation works correctly with visual updates
-        // Add extra spacing of mDotRadius on all sides so than entry animation could be run.
+        // Add extra spacing of mDotRadius on all sides so than entry animation could be run
+        // and so the hitboxes of arrows can be clicked easier.
         int width = MeasureSpec.getMode(widthMeasureSpec) == MeasureSpec.EXACTLY ?
-                MeasureSpec.getSize(widthMeasureSpec) : (int) ((mNumPages * 3 + 2) * mDotRadius);
+                MeasureSpec.getSize(widthMeasureSpec)
+                : (int) ((mNumPages * ((enableLauncherVisualRefresh())
+                        ? LARGE_WIDTH_MULTIPLIER : SMALL_WIDTH_MULTIPLIER) + 2) * mDotRadius);
         int height = MeasureSpec.getMode(heightMeasureSpec) == MeasureSpec.EXACTLY
-                ? MeasureSpec.getSize(heightMeasureSpec) : (int) (4 * mDotRadius);
+                ? MeasureSpec.getSize(heightMeasureSpec)
+                : (int) (((enableLauncherVisualRefresh())
+                        ? LARGE_HEIGHT_MULTIPLIER : SMALL_HEIGHT_MULTIPLIER) * mDotRadius);
         setMeasuredDimension(width, height);
     }
 
@@ -443,18 +474,51 @@
         float y = getHeight() / 2;
 
         if (mEntryAnimationRadiusFactors != null) {
-            // During entry animation, only draw the circles
-            // TODO(b/394355070): Verify Folder Entry Animation works correctly - visual updates
+            if (enableLauncherVisualRefresh()) {
+                x -= mDotRadius;
+                if (mIsRtl) {
+                    x = getWidth() - x;
+                    circleGap = -circleGap;
+                }
+                sTempRect.top = y - mDotRadius;
+                sTempRect.bottom = y + mDotRadius;
 
-            if (mIsRtl) {
-                x = getWidth() - x;
-                circleGap = -circleGap;
-            }
-            for (int i = 0; i < mEntryAnimationRadiusFactors.length; i++) {
-                mPaginationPaint.setAlpha(i == mActivePage ? PAGE_INDICATOR_ALPHA : DOT_ALPHA);
-                canvas.drawCircle(x, y, mDotRadius * mEntryAnimationRadiusFactors[i],
-                        mPaginationPaint);
-                x += circleGap;
+                for (int i = 0; i < mEntryAnimationRadiusFactors.length; i++) {
+                    if (i == mActivePage) {
+                        if (mIsRtl) {
+                            sTempRect.left = x - (mDotRadius * 3);
+                            sTempRect.right = x + mDotRadius;
+                            x += circleGap - (mDotRadius * 2);
+                        } else {
+                            sTempRect.left = x - mDotRadius;
+                            sTempRect.right = x + (mDotRadius * 3);
+                            x += circleGap + (mDotRadius * 2);
+                        }
+                        scale(sTempRect, mEntryAnimationRadiusFactors[i]);
+                        float scaledRadius = mDotRadius * mEntryAnimationRadiusFactors[i];
+                        mPaginationPaint.setAlpha(PAGE_INDICATOR_ALPHA);
+                        canvas.drawRoundRect(sTempRect, scaledRadius, scaledRadius,
+                                mPaginationPaint);
+                    } else {
+                        mPaginationPaint.setAlpha(DOT_ALPHA);
+                        canvas.drawCircle(x, y, mDotRadius * mEntryAnimationRadiusFactors[i],
+                                mPaginationPaint);
+                        x += circleGap;
+                    }
+                }
+            } else {
+                // During entry animation, only draw the circles
+
+                if (mIsRtl) {
+                    x = getWidth() - x;
+                    circleGap = -circleGap;
+                }
+                for (int i = 0; i < mEntryAnimationRadiusFactors.length; i++) {
+                    mPaginationPaint.setAlpha(i == mActivePage ? PAGE_INDICATOR_ALPHA : DOT_ALPHA);
+                    canvas.drawCircle(x, y, mDotRadius * mEntryAnimationRadiusFactors[i],
+                            mPaginationPaint);
+                    x += circleGap;
+                }
             }
         } else {
             // Save the current alpha value, so we can reset to it again after drawing the dots
@@ -468,12 +532,31 @@
                 sTempRect.bottom = y + mDotRadius;
                 sTempRect.left = x - diameter;
 
-                float posDif = Math.abs(mLastPosition - mCurrentPosition);
+                float currentPosition = mCurrentPosition;
+                float lastPosition = mLastPosition;
+
+                if (mIsRtl) {
+                    currentPosition = mNumPages - currentPosition - 1;
+                    lastPosition = mNumPages - lastPosition - 1;
+                }
+                float posDif = Math.abs(lastPosition - currentPosition);
                 float boundedPosition = (posDif > 1)
-                        ? Math.round(mCurrentPosition)
-                        : mCurrentPosition;
+                        ? Math.round(currentPosition)
+                        : currentPosition;
                 float bounceProgress = (posDif > 1) ? posDif - 1 : 0;
-                float bounceAdjustment = Math.abs(mCurrentPosition - boundedPosition) * diameter;
+                float bounceAdjustment = Math.abs(currentPosition - boundedPosition) * diameter;
+
+                if (mOnArrowClickListener != null && boundedPosition >= 1) {
+                    // Here we draw the Left Arrow
+                    mArrowLeft.setAlpha(alpha);
+                    int size = (int) (mGapWidth * 4);
+                    mArrowLeftBounds.left = (int) (sTempRect.left - mGapWidth - size);
+                    mArrowLeftBounds.top = (int) (y - size / 2);
+                    mArrowLeftBounds.right = (int) (sTempRect.left - mGapWidth);
+                    mArrowLeftBounds.bottom = (int) (y + size / 2);
+                    mArrowLeft.setBounds(mArrowLeftBounds);
+                    mArrowLeft.draw(canvas);
+                }
 
                 // Here we draw the dots, one at a time from the left-most dot to the right-most dot
                 // 1.0 => 000000 000000111111 000000
@@ -495,10 +578,10 @@
                         // While the animation is shifting the active pagination dots size from
                         // the previously active one, to the newly active dot, there is no bounce
                         // adjustment. The bounce happens in the "Overshoot" phase of the animation.
-                        // mLastPosition is used to determine when the currentPosition is just
+                        // lastPosition is used to determine when the currentPosition is just
                         // leaving the page, or if it is in the overshoot phase.
                         if (boundedPosition == i && bounceProgress != 0) {
-                            if (mLastPosition < mCurrentPosition) {
+                            if (lastPosition < currentPosition) {
                                 sTempRect.left -= bounceAdjustment;
                             } else {
                                 sTempRect.right += bounceAdjustment;
@@ -507,19 +590,34 @@
                     } else {
                         sTempRect.right = sTempRect.left + diameter;
 
-                        if (mLastPosition == i && bounceProgress != 0) {
-                            if (mLastPosition > mCurrentPosition) {
+                        if (lastPosition == i && bounceProgress != 0) {
+                            if (lastPosition > currentPosition) {
                                 sTempRect.left += bounceAdjustment;
                             } else {
                                 sTempRect.right -= bounceAdjustment;
                             }
                         }
                     }
+                    if (Math.round(mCurrentPosition) == i) {
+                        sLastActiveRect.set(sTempRect);
+                    }
                     canvas.drawRoundRect(sTempRect, mDotRadius, mDotRadius, mPaginationPaint);
 
                     // TODO(b/394355070) Verify RTL experience works correctly with visual updates
                     sTempRect.left = sTempRect.right + mGapWidth;
                 }
+
+                if (mOnArrowClickListener != null && boundedPosition <= mNumPages - 2) {
+                    // Here we draw the Right Arrow
+                    mArrowRight.setAlpha(alpha);
+                    int size = (int) (mGapWidth * 4);
+                    mArrowRightBounds.left = (int) sTempRect.left;
+                    mArrowRightBounds.top = (int) (y - size / 2);
+                    mArrowRightBounds.right = (int) (int) (sTempRect.left + size);
+                    mArrowRightBounds.bottom = (int) (y + size / 2);
+                    mArrowRight.setBounds(mArrowRightBounds);
+                    mArrowRight.draw(canvas);
+                }
             } else {
                 // Here we draw the dots
                 mPaginationPaint.setAlpha((int) (alpha * DOT_ALPHA_FRACTION));
@@ -538,6 +636,38 @@
         }
     }
 
+    @Override
+    public boolean onTouchEvent(MotionEvent ev) {
+        if (mOnArrowClickListener == null) {
+            // No - Op. Don't care about touch events
+        } else if ((mIsRtl && withinExpandedBounds(mArrowRightBounds, ev))
+                || (!mIsRtl && withinExpandedBounds(mArrowLeftBounds, ev))) {
+            mOnArrowClickListener.accept(Direction.START);
+        } else if ((mIsRtl && withinExpandedBounds(mArrowLeftBounds, ev))
+                || (!mIsRtl && withinExpandedBounds(mArrowRightBounds, ev))) {
+            mOnArrowClickListener.accept(Direction.END);
+        }
+        return super.onTouchEvent(ev);
+    }
+
+    // For larger Touch box
+    private boolean withinExpandedBounds(Rect rect, MotionEvent ev) {
+        RectF scaledRect = new RectF(rect);
+        scale(scaledRect, ARROW_TOUCH_BOX_FACTOR);
+        return scaledRect.contains(ev.getX(), ev.getY());
+    }
+
+    private static void scale(RectF rect, float factor) {
+        float horizontalAdjustment = rect.width() * (factor - 1) / 2;
+        float verticalAdjustment = rect.height() * (factor - 1) / 2;
+
+        rect.top -= verticalAdjustment;
+        rect.bottom += verticalAdjustment;
+
+        rect.left -= horizontalAdjustment;
+        rect.right += horizontalAdjustment;
+    }
+
     private RectF getActiveRect() {
         float startCircle = (int) mCurrentPosition;
         float delta = mCurrentPosition - startCircle;
@@ -590,8 +720,8 @@
         @Override
         public void getOutline(View view, Outline outline) {
             if (mEntryAnimationRadiusFactors == null) {
-                // TODO(b/394355070): Verify Outline works correctly with visual updates
-                RectF activeRect = getActiveRect();
+                RectF activeRect = enableLauncherVisualRefresh()
+                        ? sLastActiveRect : getActiveRect();
                 outline.setRoundRect(
                         (int) activeRect.left,
                         (int) activeRect.top,
diff --git a/src/com/android/launcher3/popup/PopupContainerWithArrow.java b/src/com/android/launcher3/popup/PopupContainerWithArrow.java
index aad1400..39f68bf 100644
--- a/src/com/android/launcher3/popup/PopupContainerWithArrow.java
+++ b/src/com/android/launcher3/popup/PopupContainerWithArrow.java
@@ -16,9 +16,12 @@
 
 package com.android.launcher3.popup;
 
+import static android.multiuser.Flags.enableMovingContentIntoPrivateSpace;
+
 import static com.android.launcher3.LauncherSettings.Favorites.CONTAINER_SHORTCUTS;
 import static com.android.launcher3.Utilities.squaredHypot;
 import static com.android.launcher3.Utilities.squaredTouchSlop;
+import static com.android.launcher3.allapps.AlphabeticalAppsList.PRIVATE_SPACE_PACKAGE;
 import static com.android.launcher3.model.data.ItemInfoWithIcon.FLAG_NOT_PINNABLE;
 import static com.android.launcher3.popup.PopupPopulator.MAX_SHORTCUTS;
 import static com.android.launcher3.util.Executors.MODEL_EXECUTOR;
@@ -65,6 +68,7 @@
 import com.android.launcher3.views.BaseDragLayer;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
@@ -207,7 +211,10 @@
         container = (PopupContainerWithArrow) launcher.getLayoutInflater().inflate(
                 R.layout.popup_container, launcher.getDragLayer(), false);
         container.configureForLauncher(launcher, item);
-        container.populateAndShowRows(icon, deepShortcutCount, systemShortcuts);
+        boolean shouldHideSystemShortcuts = enableMovingContentIntoPrivateSpace()
+                && Objects.equals(item.getTargetPackage(), PRIVATE_SPACE_PACKAGE);
+        container.populateAndShowRows(icon, deepShortcutCount,
+                shouldHideSystemShortcuts ? Collections.emptyList() : systemShortcuts);
         launcher.refreshAndBindWidgetsForPackageUser(PackageUserKey.fromItemInfo(item));
         container.requestFocus();
         return container;
diff --git a/src/com/android/launcher3/popup/PopupDataProvider.java b/src/com/android/launcher3/popup/PopupDataProvider.java
index 5c1a755..9511032 100644
--- a/src/com/android/launcher3/popup/PopupDataProvider.java
+++ b/src/com/android/launcher3/popup/PopupDataProvider.java
@@ -26,7 +26,6 @@
 import com.android.launcher3.BubbleTextView;
 import com.android.launcher3.allapps.ActivityAllAppsContainerView;
 import com.android.launcher3.dot.DotInfo;
-import com.android.launcher3.dot.FolderDotInfo;
 import com.android.launcher3.folder.Folder;
 import com.android.launcher3.folder.FolderIcon;
 import com.android.launcher3.model.data.FolderInfo;
@@ -76,11 +75,7 @@
                 ((BubbleTextView) v).applyDotState(info, true /* animate */);
             } else if (v instanceof FolderIcon icon
                     && info instanceof FolderInfo fi && fi.anyMatch(matcher)) {
-                FolderDotInfo folderDotInfo = new FolderDotInfo();
-                for (ItemInfo si : fi.getContents()) {
-                    folderDotInfo.addDotInfo(getDotInfoForItem(si));
-                }
-                icon.setDotInfo(folderDotInfo);
+                icon.updateDotInfo();
             }
 
             // process all the shortcuts
diff --git a/src/com/android/launcher3/provider/LauncherDbUtils.kt b/src/com/android/launcher3/provider/LauncherDbUtils.kt
index c92328d..3641371 100644
--- a/src/com/android/launcher3/provider/LauncherDbUtils.kt
+++ b/src/com/android/launcher3/provider/LauncherDbUtils.kt
@@ -26,19 +26,17 @@
 import android.os.Process
 import android.os.UserManager
 import android.text.TextUtils
-import com.android.launcher3.LauncherAppState
 import com.android.launcher3.LauncherSettings
 import com.android.launcher3.LauncherSettings.Favorites.CONTAINER_DESKTOP
 import com.android.launcher3.Utilities
+import com.android.launcher3.dagger.LauncherComponentProvider.appComponent
 import com.android.launcher3.icons.IconCache
-import com.android.launcher3.model.LoaderCursor
 import com.android.launcher3.model.UserManagerState
 import com.android.launcher3.pm.PinRequestHelper
 import com.android.launcher3.pm.UserCache
 import com.android.launcher3.shortcuts.ShortcutKey
 import com.android.launcher3.util.IntArray
 import com.android.launcher3.util.IntSet
-import com.android.launcher3.util.PackageManagerHelper
 
 /** A set of utility methods for Launcher DB used for DB updates and migration. */
 object LauncherDbUtils {
@@ -155,12 +153,11 @@
                 null,
                 null,
             )
-        val pmHelper = PackageManagerHelper.INSTANCE[context]
         val ums = UserManagerState()
         ums.run {
             init(UserCache.INSTANCE[context], context.getSystemService(UserManager::class.java))
         }
-        val lc = LoaderCursor(c, LauncherAppState.getInstance(context), ums, pmHelper, null)
+        val lc = context.appComponent.loaderCursorFactory.createLoaderCursor(c, ums, null)
         val deletedShortcuts = IntSet()
 
         while (lc.moveToNext()) {
diff --git a/src/com/android/launcher3/provider/RestoreDbTask.java b/src/com/android/launcher3/provider/RestoreDbTask.java
index 23941bb..f6ee26b 100644
--- a/src/com/android/launcher3/provider/RestoreDbTask.java
+++ b/src/com/android/launcher3/provider/RestoreDbTask.java
@@ -80,6 +80,7 @@
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
+import java.util.function.Supplier;
 import java.util.stream.Collectors;
 
 /**
@@ -206,7 +207,8 @@
             LauncherRestoreEventLogger restoreEventLogger =
                     LauncherRestoreEventLogger.Companion.newInstance(context);
             task.sanitizeDB(context, controller, db, backupManager, restoreEventLogger);
-            task.restoreAppWidgetIdsIfExists(context, controller, restoreEventLogger);
+            task.restoreAppWidgetIdsIfExists(context, controller, restoreEventLogger,
+                    () -> new AppWidgetHost(context, APPWIDGET_HOST_ID));
             t.commit();
             return true;
         } catch (Exception e) {
@@ -438,14 +440,13 @@
     @WorkerThread
     @VisibleForTesting
     void restoreAppWidgetIdsIfExists(Context context, ModelDbController controller,
-            LauncherRestoreEventLogger restoreEventLogger) {
+            LauncherRestoreEventLogger restoreEventLogger, Supplier<AppWidgetHost> hostSupplier) {
         LauncherPrefs lp = LauncherPrefs.get(context);
         if (lp.has(APP_WIDGET_IDS, OLD_APP_WIDGET_IDS)) {
-            AppWidgetHost host = new AppWidgetHost(context, APPWIDGET_HOST_ID);
             restoreAppWidgetIds(context, controller, restoreEventLogger,
                     IntArray.fromConcatString(lp.get(OLD_APP_WIDGET_IDS)).toArray(),
                     IntArray.fromConcatString(lp.get(APP_WIDGET_IDS)).toArray(),
-                    host);
+                    hostSupplier.get());
         } else {
             FileLog.d(TAG, "Did not receive new app widget id map during Launcher restore");
         }
diff --git a/src/com/android/launcher3/touch/AllAppsSwipeController.java b/src/com/android/launcher3/touch/AllAppsSwipeController.java
index 2cc4909..f86fd6a 100644
--- a/src/com/android/launcher3/touch/AllAppsSwipeController.java
+++ b/src/com/android/launcher3/touch/AllAppsSwipeController.java
@@ -22,6 +22,7 @@
 import static com.android.app.animation.Interpolators.FINAL_FRAME;
 import static com.android.app.animation.Interpolators.INSTANT;
 import static com.android.app.animation.Interpolators.LINEAR;
+import static com.android.app.animation.Interpolators.clampToProgress;
 import static com.android.launcher3.LauncherState.ALL_APPS;
 import static com.android.launcher3.LauncherState.NORMAL;
 import static com.android.launcher3.states.StateAnimationConfig.ANIM_ALL_APPS_FADE;
@@ -39,6 +40,7 @@
 
 import com.android.app.animation.Interpolators;
 import com.android.launcher3.AbstractFloatingView;
+import com.android.launcher3.Flags;
 import com.android.launcher3.Launcher;
 import com.android.launcher3.LauncherState;
 import com.android.launcher3.states.StateAnimationConfig;
@@ -53,10 +55,10 @@
     private static final float ALL_APPS_SCRIM_VISIBLE_THRESHOLD = 0.1f;
     private static final float ALL_APPS_STAGGERED_FADE_THRESHOLD = 0.5f;
 
-    public static final Interpolator ALL_APPS_SCRIM_RESPONDER =
+    private static final Interpolator ALL_APPS_SCRIM_RESPONDER =
             Interpolators.clampToProgress(
                     LINEAR, ALL_APPS_SCRIM_VISIBLE_THRESHOLD, ALL_APPS_STAGGERED_FADE_THRESHOLD);
-    public static final Interpolator ALL_APPS_CLAMPING_RESPONDER =
+    private static final Interpolator ALL_APPS_CLAMPING_RESPONDER =
             Interpolators.clampToProgress(
                     LINEAR,
                     1 - ALL_APPS_CONTENT_FADE_MAX_CLAMPING_THRESHOLD,
@@ -207,7 +209,16 @@
             }
             config.setInterpolator(ANIM_WORKSPACE_SCALE, DECELERATED_EASE);
             config.setInterpolator(ANIM_DEPTH, DECELERATED_EASE);
-            if (launcher.getDeviceProfile().isPhone) {
+            if (Flags.allAppsBlur()) {
+                if (!config.isUserControlled()) {
+                    config.setInterpolator(ANIM_DEPTH, EMPHASIZED_DECELERATE);
+                }
+                config.setInterpolator(ANIM_WORKSPACE_FADE,
+                        clampToProgress(LINEAR, 1 - ALL_APPS_SCRIM_VISIBLE_THRESHOLD, 1));
+                config.setInterpolator(ANIM_HOTSEAT_FADE,
+                        clampToProgress(LINEAR, 1 - ALL_APPS_SCRIM_VISIBLE_THRESHOLD, 1));
+            } else if (launcher.getDeviceProfile().isPhone) {
+                // On phones without blur, reveal the workspace and hotseat when leaving All Apps.
                 config.setInterpolator(ANIM_WORKSPACE_FADE, INSTANT);
                 config.setInterpolator(ANIM_HOTSEAT_FADE, INSTANT);
                 config.animFlags |= StateAnimationConfig.SKIP_DEPTH_CONTROLLER;
@@ -253,7 +264,14 @@
             }
             config.setInterpolator(ANIM_WORKSPACE_SCALE, DECELERATED_EASE);
             config.setInterpolator(ANIM_DEPTH, DECELERATED_EASE);
-            if (launcher.getDeviceProfile().isPhone) {
+            if (Flags.allAppsBlur()) {
+                config.setInterpolator(ANIM_DEPTH, LINEAR);
+                config.setInterpolator(ANIM_WORKSPACE_FADE,
+                        clampToProgress(LINEAR, 0, ALL_APPS_SCRIM_VISIBLE_THRESHOLD));
+                config.setInterpolator(ANIM_HOTSEAT_FADE,
+                        clampToProgress(LINEAR, 0, ALL_APPS_SCRIM_VISIBLE_THRESHOLD));
+            } else if (launcher.getDeviceProfile().isPhone) {
+                // On phones without blur, hide the workspace and hotseat when entering All Apps.
                 config.setInterpolator(ANIM_WORKSPACE_FADE, FINAL_FRAME);
                 config.setInterpolator(ANIM_HOTSEAT_FADE, FINAL_FRAME);
                 config.animFlags |= StateAnimationConfig.SKIP_DEPTH_CONTROLLER;
diff --git a/src/com/android/launcher3/touch/WorkspaceTouchListener.java b/src/com/android/launcher3/touch/WorkspaceTouchListener.java
index d72e6f9..576f176 100644
--- a/src/com/android/launcher3/touch/WorkspaceTouchListener.java
+++ b/src/com/android/launcher3/touch/WorkspaceTouchListener.java
@@ -131,7 +131,7 @@
         }
 
         boolean isInAllAppsBottomSheet = mLauncher.isInState(ALL_APPS)
-                && mLauncher.getDeviceProfile().isTablet;
+                && mLauncher.getDeviceProfile().shouldShowAllAppsOnSheet();
 
         final boolean result;
         if (mLongPressState == STATE_COMPLETED) {
diff --git a/src/com/android/launcher3/util/ContentWriter.java b/src/com/android/launcher3/util/ContentWriter.java
index 9910dc2..c2c1fee 100644
--- a/src/com/android/launcher3/util/ContentWriter.java
+++ b/src/com/android/launcher3/util/ContentWriter.java
@@ -23,7 +23,6 @@
 
 import com.android.launcher3.LauncherAppState;
 import com.android.launcher3.LauncherSettings;
-import com.android.launcher3.LauncherSettings.Favorites;
 import com.android.launcher3.icons.BitmapInfo;
 import com.android.launcher3.icons.GraphicsUtils;
 import com.android.launcher3.model.ModelDbController;
@@ -107,7 +106,7 @@
     public int commit() {
         if (mCommitParams != null) {
             return mCommitParams.mDbController.update(
-                    Favorites.TABLE_NAME, getValues(mContext),
+                    getValues(mContext),
                     mCommitParams.mWhere, mCommitParams.mSelectionArgs);
         }
         return 0;
diff --git a/src/com/android/launcher3/util/ItemInflater.kt b/src/com/android/launcher3/util/ItemInflater.kt
index ebf4656..acb3c4e 100644
--- a/src/com/android/launcher3/util/ItemInflater.kt
+++ b/src/com/android/launcher3/util/ItemInflater.kt
@@ -24,6 +24,7 @@
 import android.view.View.OnFocusChangeListener
 import android.view.ViewGroup
 import com.android.launcher3.BubbleTextView
+import com.android.launcher3.LauncherAppState
 import com.android.launcher3.LauncherSettings.Favorites
 import com.android.launcher3.R
 import com.android.launcher3.apppairs.AppPairIcon
@@ -46,10 +47,11 @@
     private val widgetHolder: LauncherWidgetHolder,
     private val clickListener: OnClickListener,
     private val focusListener: OnFocusChangeListener,
-    private val defaultParent: ViewGroup
+    private val defaultParent: ViewGroup,
 ) where T : Context, T : ActivityContext {
 
-    private val widgetInflater = WidgetInflater(context)
+    private val widgetInflater =
+        WidgetInflater(context, LauncherAppState.getInstance(context).isSafeModeEnabled)
 
     @JvmOverloads
     fun inflateItem(item: ItemInfo, writer: ModelWriter, nullableParent: ViewGroup? = null): View? {
@@ -75,7 +77,7 @@
                     R.layout.folder_icon,
                     context,
                     parent,
-                    item as FolderInfo
+                    item as FolderInfo,
                 )
             Favorites.ITEM_TYPE_APP_PAIR ->
                 return AppPairIcon.inflateIcon(
@@ -83,7 +85,7 @@
                     context,
                     parent,
                     item as AppPairInfo,
-                    BubbleTextView.DISPLAY_WORKSPACE
+                    BubbleTextView.DISPLAY_WORKSPACE,
                 )
             Favorites.ITEM_TYPE_APPWIDGET,
             Favorites.ITEM_TYPE_CUSTOM_APPWIDGET ->
diff --git a/src/com/android/launcher3/util/SimpleBroadcastReceiver.java b/src/com/android/launcher3/util/SimpleBroadcastReceiver.java
index 7a40abe..53e0bce 100644
--- a/src/com/android/launcher3/util/SimpleBroadcastReceiver.java
+++ b/src/com/android/launcher3/util/SimpleBroadcastReceiver.java
@@ -123,6 +123,32 @@
         }
     }
 
+    /**
+     * Same as {@link #register(Runnable, int, String...)} above but with additional permission
+     * params utilizine the original {@link Context}.
+     */
+    @AnyThread
+    public void register(@Nullable Runnable completionCallback,
+                         String broadcastPermission, int flags, String... actions) {
+        if (Looper.myLooper() == mHandler.getLooper()) {
+            registerInternal(mContext, completionCallback, broadcastPermission, flags, actions);
+        } else {
+            mHandler.post(() -> registerInternal(mContext, completionCallback, broadcastPermission,
+                    flags, actions));
+        }
+    }
+
+    /** Register broadcast receiver with permission and run completion callback if passed. */
+    @AnyThread
+    private void registerInternal(
+            @NonNull Context context, @Nullable Runnable completionCallback,
+            String broadcastPermission, int flags, String... actions) {
+        context.registerReceiver(this, getFilter(actions), broadcastPermission, null, flags);
+        if (completionCallback != null) {
+            completionCallback.run();
+        }
+    }
+
     /** Same as {@link #register(Runnable, String...)} above but with pkg name. */
     @AnyThread
     public void registerPkgActions(@Nullable String pkg, String... actions) {
diff --git a/src/com/android/launcher3/views/OptionsPopupView.java b/src/com/android/launcher3/views/OptionsPopupView.java
index 82cc40d..8c01c59 100644
--- a/src/com/android/launcher3/views/OptionsPopupView.java
+++ b/src/com/android/launcher3/views/OptionsPopupView.java
@@ -19,6 +19,7 @@
 import static com.android.launcher3.LauncherState.EDIT_MODE;
 import static com.android.launcher3.config.FeatureFlags.MULTI_SELECT_EDIT_MODE;
 import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.IGNORE;
+import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_ALL_APPS_TAP_OR_LONGPRESS;
 import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_SETTINGS_BUTTON_TAP_OR_LONGPRESS;
 import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_WIDGETSTRAY_BUTTON_TAP_OR_LONGPRESS;
 
@@ -219,6 +220,11 @@
                     OptionsPopupView::enterHomeGardening));
         }
         options.add(new OptionItem(launcher,
+                R.string.all_apps_home_screen,
+                R.drawable.ic_apps,
+                LAUNCHER_ALL_APPS_TAP_OR_LONGPRESS,
+                OptionsPopupView::enterAllApps));
+        options.add(new OptionItem(launcher,
                 R.string.settings_button_text,
                 R.drawable.ic_setting,
                 LAUNCHER_SETTINGS_BUTTON_TAP_OR_LONGPRESS,
@@ -226,6 +232,20 @@
         return options;
     }
 
+    /**
+     * Used by the options to open All Apps, uses an intent as to not tie the implementation of
+     * opening All Apps with OptionsPopup, instead it uses the public API to open All Apps.
+     */
+    public static boolean enterAllApps(View view) {
+        Launcher launcher = Launcher.getLauncher(view.getContext());
+        launcher.startActivity(
+                new Intent(Intent.ACTION_ALL_APPS)
+                .setComponent(launcher.getComponentName())
+                .setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP)
+        );
+        return true;
+    }
+
     private static boolean enterHomeGardening(View view) {
         Launcher launcher = Launcher.getLauncher(view.getContext());
         launcher.getStateManager().goToState(EDIT_MODE);
diff --git a/src/com/android/launcher3/views/ScrimView.java b/src/com/android/launcher3/views/ScrimView.java
index ce58de1..ec71f31 100644
--- a/src/com/android/launcher3/views/ScrimView.java
+++ b/src/com/android/launcher3/views/ScrimView.java
@@ -54,8 +54,7 @@
     }
 
     @Override
-    public void setInsets(Rect insets) {
-    }
+    public void setInsets(Rect insets) {}
 
     @Override
     public boolean hasOverlappingRendering() {
diff --git a/src/com/android/launcher3/widget/LauncherAppWidgetHost.java b/src/com/android/launcher3/widget/LauncherAppWidgetHost.java
index 91b899c..63d2954 100644
--- a/src/com/android/launcher3/widget/LauncherAppWidgetHost.java
+++ b/src/com/android/launcher3/widget/LauncherAppWidgetHost.java
@@ -16,8 +16,6 @@
 
 package com.android.launcher3.widget;
 
-import static com.android.launcher3.widget.LauncherWidgetHolder.APPWIDGET_HOST_ID;
-
 import android.appwidget.AppWidgetHost;
 import android.appwidget.AppWidgetProviderInfo;
 import android.content.Context;
@@ -26,49 +24,18 @@
 import androidx.annotation.Nullable;
 import androidx.annotation.VisibleForTesting;
 
-import com.android.launcher3.LauncherAppState;
-import com.android.launcher3.util.Executors;
-import com.android.launcher3.widget.LauncherWidgetHolder.ProviderChangedListener;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.function.IntConsumer;
-
 /**
  * Specific {@link AppWidgetHost} that creates our {@link LauncherAppWidgetHostView}
  * which correctly captures all long-press events. This ensures that users can
  * always pick up and move widgets.
  */
-class LauncherAppWidgetHost extends AppWidgetHost {
-    @NonNull
-    private final List<ProviderChangedListener> mProviderChangeListeners;
-
-    @NonNull
-    private final Context mContext;
-
-    @Nullable
-    private final IntConsumer mAppWidgetRemovedCallback;
+class LauncherAppWidgetHost extends ListenableAppWidgetHost {
 
     @Nullable
     private ListenableHostView mViewToRecycle;
 
-    public LauncherAppWidgetHost(@NonNull Context context,
-            @Nullable IntConsumer appWidgetRemovedCallback,
-            List<ProviderChangedListener> providerChangeListeners) {
-        super(context, APPWIDGET_HOST_ID);
-        mContext = context;
-        mAppWidgetRemovedCallback = appWidgetRemovedCallback;
-        mProviderChangeListeners = providerChangeListeners;
-    }
-
-    @Override
-    protected void onProvidersChanged() {
-        if (!mProviderChangeListeners.isEmpty()) {
-            for (LauncherWidgetHolder.ProviderChangedListener callback :
-                    new ArrayList<>(mProviderChangeListeners)) {
-                callback.notifyWidgetProvidersChanged();
-            }
-        }
+    LauncherAppWidgetHost(@NonNull Context context, int appWidgetId) {
+        super(context, appWidgetId);
     }
 
     /**
@@ -94,35 +61,6 @@
     }
 
     /**
-     * Called when the AppWidget provider for a AppWidget has been upgraded to a new apk.
-     */
-    @Override
-    protected void onProviderChanged(int appWidgetId, @NonNull AppWidgetProviderInfo appWidget) {
-        LauncherAppWidgetProviderInfo info = LauncherAppWidgetProviderInfo.fromProviderInfo(
-                mContext, appWidget);
-        super.onProviderChanged(appWidgetId, info);
-        // The super method updates the dimensions of the providerInfo. Update the
-        // launcher spans accordingly.
-        info.initSpans(mContext, LauncherAppState.getIDP(mContext));
-    }
-
-    /**
-     * Called on an appWidget is removed for a widgetId
-     *
-     * @param appWidgetId TODO: make this override when SDK is updated
-     */
-    @Override
-    public void onAppWidgetRemoved(int appWidgetId) {
-        if (mAppWidgetRemovedCallback == null) {
-            return;
-        }
-        // Route the call via model thread, in case it comes while a loader-bind is in progress
-        Executors.MODEL_EXECUTOR.execute(
-                () -> Executors.MAIN_EXECUTOR.execute(
-                        () -> mAppWidgetRemovedCallback.accept(appWidgetId)));
-    }
-
-    /**
      * The same as super.clearViews(), except with the scope exposed
      */
     @Override
diff --git a/src/com/android/launcher3/widget/LauncherWidgetHolder.java b/src/com/android/launcher3/widget/LauncherWidgetHolder.java
index 78197e2..642f35a 100644
--- a/src/com/android/launcher3/widget/LauncherWidgetHolder.java
+++ b/src/com/android/launcher3/widget/LauncherWidgetHolder.java
@@ -20,10 +20,9 @@
 import static com.android.launcher3.BuildConfig.WIDGETS_ENABLED;
 import static com.android.launcher3.Flags.enableWorkspaceInflation;
 import static com.android.launcher3.util.Executors.MAIN_EXECUTOR;
-import static com.android.launcher3.util.Executors.UI_HELPER_EXECUTOR;
 import static com.android.launcher3.widget.LauncherAppWidgetProviderInfo.fromProviderInfo;
+import static com.android.launcher3.widget.ListenableAppWidgetHost.getWidgetHolderExecutor;
 
-import android.appwidget.AppWidgetHost;
 import android.appwidget.AppWidgetHostView;
 import android.appwidget.AppWidgetManager;
 import android.appwidget.AppWidgetProviderInfo;
@@ -32,6 +31,7 @@
 import android.content.Intent;
 import android.os.Bundle;
 import android.os.Looper;
+import android.util.Log;
 import android.util.SparseArray;
 import android.widget.Toast;
 
@@ -43,18 +43,23 @@
 import com.android.launcher3.BaseActivity;
 import com.android.launcher3.R;
 import com.android.launcher3.Utilities;
+import com.android.launcher3.dagger.LauncherComponentProvider;
 import com.android.launcher3.model.data.ItemInfo;
 import com.android.launcher3.testing.TestLogging;
 import com.android.launcher3.testing.shared.TestProtocol;
-import com.android.launcher3.util.LooperExecutor;
-import com.android.launcher3.util.ResourceBasedOverride;
 import com.android.launcher3.util.SafeCloseable;
 import com.android.launcher3.views.ActivityContext;
+import com.android.launcher3.widget.ListenableAppWidgetHost.ProviderChangedListener;
 import com.android.launcher3.widget.custom.CustomWidgetManager;
 
+import dagger.assisted.Assisted;
+import dagger.assisted.AssistedFactory;
+import dagger.assisted.AssistedInject;
+
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Consumer;
 import java.util.function.IntConsumer;
 
 /**
@@ -62,51 +67,57 @@
  * background.
  */
 public class LauncherWidgetHolder {
+
+    private static final String TAG = "LauncherWidgetHolder";
+
     public static final int APPWIDGET_HOST_ID = 1024;
 
     protected static final int FLAG_LISTENING = 1;
     protected static final int FLAG_STATE_IS_NORMAL = 1 << 1;
     protected static final int FLAG_ACTIVITY_STARTED = 1 << 2;
     protected static final int FLAG_ACTIVITY_RESUMED = 1 << 3;
+
     private static final int FLAGS_SHOULD_LISTEN =
             FLAG_STATE_IS_NORMAL | FLAG_ACTIVITY_STARTED | FLAG_ACTIVITY_RESUMED;
 
-    @NonNull
-    protected final Context mContext;
-
-    @NonNull
-    private final AppWidgetHost mWidgetHost;
-
-    @NonNull
-    protected final SparseArray<LauncherAppWidgetHostView> mViews = new SparseArray<>();
-    protected final List<ProviderChangedListener> mProviderChangedListeners = new ArrayList<>();
-
-    protected AtomicInteger mFlags = new AtomicInteger(FLAG_STATE_IS_NORMAL);
-
     // TODO(b/191735836): Replace with ActivityOptions.KEY_SPLASH_SCREEN_STYLE when un-hidden
     private static final String KEY_SPLASH_SCREEN_STYLE = "android.activity.splashScreenStyle";
     // TODO(b/191735836): Replace with SplashScreen.SPLASH_SCREEN_STYLE_EMPTY when un-hidden
     private static final int SPLASH_SCREEN_STYLE_EMPTY = 0;
 
-    protected LauncherWidgetHolder(@NonNull Context context,
-            @Nullable IntConsumer appWidgetRemovedCallback) {
+    @NonNull
+    protected final Context mContext;
+
+    @NonNull
+    protected final ListenableAppWidgetHost mWidgetHost;
+
+    @NonNull
+    protected final SparseArray<LauncherAppWidgetHostView> mViews = new SparseArray<>();
+
+    /** package visibility */
+    final List<ProviderChangedListener> mProviderChangedListeners = new ArrayList<>();
+
+    protected AtomicInteger mFlags = new AtomicInteger(FLAG_STATE_IS_NORMAL);
+
+    @Nullable
+    private Consumer<LauncherAppWidgetHostView> mOnViewCreationCallback;
+
+    /** package visibility */
+    @Nullable IntConsumer mAppWidgetRemovedCallback;
+
+    @AssistedInject
+    protected LauncherWidgetHolder(@Assisted("UI_CONTEXT") @NonNull Context context) {
+        this(context, new LauncherAppWidgetHost(context, APPWIDGET_HOST_ID));
+    }
+
+    protected LauncherWidgetHolder(
+            @NonNull Context context, @NonNull ListenableAppWidgetHost appWidgetHost) {
         mContext = context;
-        mWidgetHost = createHost(context, appWidgetRemovedCallback);
+        mWidgetHost = appWidgetHost;
+        MAIN_EXECUTOR.execute(() ->  mWidgetHost.getHolders().add(this));
     }
 
-    protected AppWidgetHost createHost(
-            Context context, @Nullable IntConsumer appWidgetRemovedCallback) {
-        return new LauncherAppWidgetHost(
-                context, appWidgetRemovedCallback, mProviderChangedListeners);
-    }
-
-    protected LooperExecutor getWidgetHolderExecutor() {
-        return UI_HELPER_EXECUTOR;
-    }
-
-    /**
-     * Starts listening to the widget updates from the server side
-     */
+    /** Starts listening to the widget updates from the server side */
     public void startListening() {
         if (!WIDGETS_ENABLED) {
             return;
@@ -127,13 +138,11 @@
             // TODO: Investigate why widgetHost.startListening() always return non-empty updates
             setListeningFlag(true);
 
-            MAIN_EXECUTOR.execute(() -> updateDeferredView());
+            MAIN_EXECUTOR.execute(this::updateDeferredView);
         });
     }
 
-    /**
-     * Update any views which have been deferred because the host was not listening.
-     */
+    /** Update any views which have been deferred because the host was not listening */
     protected void updateDeferredView() {
         // Update any views which have been deferred because the host was not listening.
         // We go in reverse order and inflate any deferred or cached widget
@@ -180,7 +189,14 @@
      * Called when the launcher is destroyed
      */
     public void destroy() {
-        // No-op
+        try {
+            MAIN_EXECUTOR.submit(() -> {
+                clearViews();
+                mWidgetHost.getHolders().remove(this);
+            }).get();
+        } catch (Exception e) {
+            Log.e(TAG, "Failed to remove self from holder list", e);
+        }
     }
 
     /**
@@ -198,8 +214,7 @@
      * Add a listener that is triggered when the providers of the widgets are changed
      * @param listener The listener that notifies when the providers changed
      */
-    public void addProviderChangeListener(
-            @NonNull LauncherWidgetHolder.ProviderChangedListener listener) {
+    public void addProviderChangeListener(@NonNull ProviderChangedListener listener) {
         MAIN_EXECUTOR.execute(() -> mProviderChangedListeners.add(listener));
     }
 
@@ -207,12 +222,23 @@
      * Remove the specified listener from the host
      * @param listener The listener that is to be removed from the host
      */
-    public void removeProviderChangeListener(
-            LauncherWidgetHolder.ProviderChangedListener listener) {
+    public void removeProviderChangeListener(ProviderChangedListener listener) {
         MAIN_EXECUTOR.execute(() -> mProviderChangedListeners.remove(listener));
     }
 
     /**
+     * Sets a callbacks for whenever a widget view is created
+     */
+    public void setOnViewCreationCallback(@Nullable Consumer<LauncherAppWidgetHostView> callback) {
+        mOnViewCreationCallback = callback;
+    }
+
+    /** Sets a callback for listening app widget removals */
+    public void setAppWidgetRemovedCallback(@Nullable IntConsumer callback) {
+        mAppWidgetRemovedCallback = callback;
+    }
+
+    /**
      * Starts the configuration activity for the widget
      * @param activity The activity in which to start the configuration page
      * @param widgetId The ID of the widget
@@ -284,9 +310,7 @@
         activity.startActivityForResult(intent, requestCode);
     }
 
-    /**
-     * Stop the host from listening to the widget updates
-     */
+    /** Stop the host from listening to the widget updates */
     public void stopListening() {
         if (!WIDGETS_ENABLED) {
             return;
@@ -298,8 +322,8 @@
     }
 
     /**
-     * Update {@link FLAG_LISTENING} on {@link mFlags} after making binder calls from
-     * {@link sWidgetHost}.
+     * Update {@link #FLAG_LISTENING} on {@link #mFlags} after making binder calls from
+     * {@link #mWidgetHost}.
      */
     @WorkerThread
     protected void setListeningFlag(final boolean isListening) {
@@ -350,6 +374,7 @@
         }
 
         LauncherAppWidgetHostView view = createViewInternal(appWidgetId, appWidget);
+        if (mOnViewCreationCallback != null) mOnViewCreationCallback.accept(view);
         // Do not update mViews on a background thread call, as the holder is not thread safe.
         if (!enableWorkspaceInflation() || Looper.myLooper() == Looper.getMainLooper()) {
             mViews.put(appWidgetId, view);
@@ -368,8 +393,8 @@
 
         // Binder can also inflate placeholder widgets in case of backup-restore. Skip
         // attaching such widgets
-        boolean isRealWidget = ((view instanceof PendingAppWidgetHostView pw)
-                ? pw.isDeferredWidget() : true)
+        boolean isRealWidget = (!(view instanceof PendingAppWidgetHostView pw)
+                || pw.isDeferredWidget())
                 && view.getAppWidgetInfo() != null;
         if (isRealWidget && mViews.get(view.getAppWidgetId()) != view) {
             view = recycleExistingView(view);
@@ -446,28 +471,13 @@
         }
     }
 
-    /**
-     * Listener for getting notifications on provider changes.
-     */
-    public interface ProviderChangedListener {
-        /**
-         * Notify the listener that the providers have changed
-         */
-        void notifyWidgetProvidersChanged();
-    }
-
-    /**
-     * Clears all the views from the host
-     */
+    /** Clears all the views from the host */
     public void clearViews() {
-        LauncherAppWidgetHost tempHost = (LauncherAppWidgetHost) mWidgetHost;
-        tempHost.clearViews();
+        ((LauncherAppWidgetHost) mWidgetHost).clearViews();
         mViews.clear();
     }
 
-    /**
-     * Clears all the internal widget views
-     */
+    /** Clears all the internal widget views */
     public void clearWidgetViews() {
         clearViews();
     }
@@ -514,32 +524,19 @@
      * Returns the new LauncherWidgetHolder instance
      */
     public static LauncherWidgetHolder newInstance(Context context) {
-        return HolderFactory.newFactory(context).newInstance(context, null);
+        return LauncherComponentProvider.get(context).getWidgetHolderFactory().newInstance(context);
     }
 
-    /**
-     * A factory class that generates new instances of {@code LauncherWidgetHolder}
-     */
-    public static class HolderFactory implements ResourceBasedOverride {
+    /** A factory that generates new instances of {@code LauncherWidgetHolder} */
+    public interface WidgetHolderFactory {
 
-        /**
-         * @param context The context of the caller
-         * @param appWidgetRemovedCallback The callback that is called when widgets are removed
-         * @return A new instance of {@code LauncherWidgetHolder}
-         */
-        public LauncherWidgetHolder newInstance(@NonNull Context context,
-                @Nullable IntConsumer appWidgetRemovedCallback) {
-            return new LauncherWidgetHolder(context, appWidgetRemovedCallback);
-        }
+        LauncherWidgetHolder newInstance(@NonNull Context context);
+    }
 
-        /**
-         * @param context The context of the caller
-         * @return A new instance of factory class for widget holders. If not specified, returning
-         * {@code HolderFactory} by default.
-         */
-        public static HolderFactory newFactory(Context context) {
-            return Overrides.getObject(
-                    HolderFactory.class, context, R.string.widget_holder_factory_class);
-        }
+    /** A factory that generates new instances of {@code LauncherWidgetHolder} */
+    @AssistedFactory
+    public interface WidgetHolderFactoryImpl extends WidgetHolderFactory {
+
+        LauncherWidgetHolder newInstance(@Assisted("UI_CONTEXT") @NonNull Context context);
     }
 }
diff --git a/src/com/android/launcher3/widget/ListenableAppWidgetHost.kt b/src/com/android/launcher3/widget/ListenableAppWidgetHost.kt
new file mode 100644
index 0000000..58bf0aa
--- /dev/null
+++ b/src/com/android/launcher3/widget/ListenableAppWidgetHost.kt
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.launcher3.widget
+
+import android.appwidget.AppWidgetHost
+import android.appwidget.AppWidgetProviderInfo
+import android.content.Context
+import com.android.launcher3.InvariantDeviceProfile
+import com.android.launcher3.util.Executors
+import com.android.launcher3.util.Executors.MAIN_EXECUTOR
+import com.android.launcher3.util.Executors.MODEL_EXECUTOR
+import com.android.launcher3.util.LooperExecutor
+
+open class ListenableAppWidgetHost(private val ctx: Context, hostId: Int) :
+    AppWidgetHost(ctx, hostId) {
+
+    protected val holders = mutableListOf<LauncherWidgetHolder>()
+
+    override fun onProvidersChanged() {
+        MAIN_EXECUTOR.execute {
+            holders.forEach { holder ->
+                // Listeners might remove themselves from the list during the iteration.
+                // Creating a copy of the list to avoid exceptions for concurrent modification.
+                holder.mProviderChangedListeners.toList().forEach {
+                    it.notifyWidgetProvidersChanged()
+                }
+            }
+        }
+    }
+
+    override fun onAppWidgetRemoved(appWidgetId: Int) {
+        // Route the call via model thread, in case it comes while a loader-bind is in progress
+        MODEL_EXECUTOR.execute {
+            MAIN_EXECUTOR.execute {
+                holders.forEach { it.mAppWidgetRemovedCallback?.accept(appWidgetId) }
+            }
+        }
+    }
+
+    override fun onProviderChanged(appWidgetId: Int, appWidget: AppWidgetProviderInfo) {
+        val info = LauncherAppWidgetProviderInfo.fromProviderInfo(ctx, appWidget)
+        super.onProviderChanged(appWidgetId, info)
+        // The super method updates the dimensions of the providerInfo. Update the
+        // launcher spans accordingly.
+        info.initSpans(ctx, InvariantDeviceProfile.INSTANCE.get(ctx))
+    }
+
+    /** Listener for getting notifications on provider changes. */
+    fun interface ProviderChangedListener {
+        /** Notify the listener that the providers have changed */
+        fun notifyWidgetProvidersChanged()
+    }
+
+    companion object {
+
+        @JvmStatic val widgetHolderExecutor: LooperExecutor = Executors.UI_HELPER_EXECUTOR
+    }
+}
diff --git a/src/com/android/launcher3/widget/PendingAppWidgetHostView.java b/src/com/android/launcher3/widget/PendingAppWidgetHostView.java
index cd8e457..1c29f89 100644
--- a/src/com/android/launcher3/widget/PendingAppWidgetHostView.java
+++ b/src/com/android/launcher3/widget/PendingAppWidgetHostView.java
@@ -66,7 +66,7 @@
 import com.android.launcher3.util.RunnableList;
 import com.android.launcher3.util.SafeCloseable;
 import com.android.launcher3.util.Themes;
-import com.android.launcher3.widget.LauncherWidgetHolder.ProviderChangedListener;
+import com.android.launcher3.widget.ListenableAppWidgetHost.ProviderChangedListener;
 
 import java.util.List;
 
diff --git a/src/com/android/launcher3/widget/WidgetInflater.kt b/src/com/android/launcher3/widget/WidgetInflater.kt
index d6cadc7..03f680a 100644
--- a/src/com/android/launcher3/widget/WidgetInflater.kt
+++ b/src/com/android/launcher3/widget/WidgetInflater.kt
@@ -19,14 +19,21 @@
 import android.content.Context
 import com.android.launcher3.BuildConfig
 import com.android.launcher3.Launcher
-import com.android.launcher3.LauncherAppState
 import com.android.launcher3.backuprestore.LauncherRestoreEventLogger.RestoreError
+import com.android.launcher3.dagger.ApplicationContext
 import com.android.launcher3.logging.FileLog
 import com.android.launcher3.model.data.LauncherAppWidgetInfo
 import com.android.launcher3.qsb.QsbContainerView
+import javax.inject.Inject
+import javax.inject.Named
 
 /** Utility class for handling widget inflation taking into account all the restore state updates */
-class WidgetInflater(private val context: Context) {
+class WidgetInflater
+@Inject
+constructor(
+    @ApplicationContext private val context: Context,
+    @Named("SAFE_MODE") private val isSafeModeEnabled: Boolean,
+) {
 
     private val widgetHelper = WidgetManagerHelper(context)
 
@@ -41,9 +48,8 @@
                 )
             }
         }
-        if (LauncherAppState.INSTANCE.get(context).isSafeModeEnabled) {
-            return InflationResult(TYPE_PENDING)
-        }
+        if (isSafeModeEnabled) return InflationResult(TYPE_PENDING)
+
         val appWidgetInfo: LauncherAppWidgetProviderInfo?
         var removalReason = ""
         @RestoreError var logReason = RestoreError.OTHER_WIDGET_INFLATION_FAIL
diff --git a/src/com/android/launcher3/workprofile/PersonalWorkSlidingTabStrip.java b/src/com/android/launcher3/workprofile/PersonalWorkSlidingTabStrip.java
index e94f3a0..185c3ee 100644
--- a/src/com/android/launcher3/workprofile/PersonalWorkSlidingTabStrip.java
+++ b/src/com/android/launcher3/workprofile/PersonalWorkSlidingTabStrip.java
@@ -26,9 +26,12 @@
 
 import com.android.launcher3.DeviceProfile;
 import com.android.launcher3.R;
+import com.android.launcher3.pageindicators.Direction;
 import com.android.launcher3.pageindicators.PageIndicator;
 import com.android.launcher3.views.ActivityContext;
 
+import java.util.function.Consumer;
+
 /**
  * Supports two indicator colors, dedicated for personal and work tabs.
  */
@@ -78,6 +81,11 @@
     }
 
     @Override
+    public void setArrowClickListener(Consumer<Direction> listener) {
+        // No-Op. All Apps doesn't need accessibility arrows for single click navigation.
+    }
+
+    @Override
     public boolean hasOverlappingRendering() {
         return false;
     }
diff --git a/src_no_quickstep/com/android/launcher3/dagger/Modules.kt b/src_no_quickstep/com/android/launcher3/dagger/Modules.kt
index c3bf7c5..7dbe9c3 100644
--- a/src_no_quickstep/com/android/launcher3/dagger/Modules.kt
+++ b/src_no_quickstep/com/android/launcher3/dagger/Modules.kt
@@ -16,6 +16,9 @@
 
 package com.android.launcher3.dagger
 
+import com.android.launcher3.widget.LauncherWidgetHolder.WidgetHolderFactory
+import com.android.launcher3.widget.LauncherWidgetHolder.WidgetHolderFactoryImpl
+import dagger.Binds
 import dagger.Module
 
 private object Modules {}
@@ -24,6 +27,12 @@
 
 @Module abstract class ApiWrapperModule {}
 
+@Module
+abstract class WidgetModule {
+    @Binds
+    abstract fun bindWidgetHolderFactory(factor: WidgetHolderFactoryImpl): WidgetHolderFactory
+}
+
 @Module abstract class PluginManagerWrapperModule {}
 
 @Module object StaticObjectModule {}
diff --git a/tests/assets/dumpTests/DeviceProfileDumpTest/phonePortrait.txt b/tests/assets/dumpTests/DeviceProfileDumpTest/phonePortrait.txt
index a13d63b..6a0d774 100644
--- a/tests/assets/dumpTests/DeviceProfileDumpTest/phonePortrait.txt
+++ b/tests/assets/dumpTests/DeviceProfileDumpTest/phonePortrait.txt
@@ -53,7 +53,7 @@
 	bottomSheetTopPadding: 146.0px (55.61905dp)
 	bottomSheetOpenDuration: 267
 	bottomSheetCloseDuration: 267
-	bottomSheetWorkspaceScale: 1.0
+	bottomSheetWorkspaceScale: 0.97
 	bottomSheetDepth: 0.0
 	allAppsShiftRange: 2400.0px (914.2857dp)
 	allAppsOpenDuration: 600
diff --git a/tests/assets/dumpTests/DeviceProfileDumpTest/phonePortrait3Button.txt b/tests/assets/dumpTests/DeviceProfileDumpTest/phonePortrait3Button.txt
index 3c24885..9e2397c 100644
--- a/tests/assets/dumpTests/DeviceProfileDumpTest/phonePortrait3Button.txt
+++ b/tests/assets/dumpTests/DeviceProfileDumpTest/phonePortrait3Button.txt
@@ -53,7 +53,7 @@
 	bottomSheetTopPadding: 146.0px (55.61905dp)
 	bottomSheetOpenDuration: 267
 	bottomSheetCloseDuration: 267
-	bottomSheetWorkspaceScale: 1.0
+	bottomSheetWorkspaceScale: 0.97
 	bottomSheetDepth: 0.0
 	allAppsShiftRange: 2400.0px (914.2857dp)
 	allAppsOpenDuration: 600
diff --git a/tests/assets/dumpTests/DeviceProfileDumpTest/phoneVerticalBar.txt b/tests/assets/dumpTests/DeviceProfileDumpTest/phoneVerticalBar.txt
index 5e06513..f25ab42 100644
--- a/tests/assets/dumpTests/DeviceProfileDumpTest/phoneVerticalBar.txt
+++ b/tests/assets/dumpTests/DeviceProfileDumpTest/phoneVerticalBar.txt
@@ -53,7 +53,7 @@
 	bottomSheetTopPadding: 114.0px (43.42857dp)
 	bottomSheetOpenDuration: 267
 	bottomSheetCloseDuration: 267
-	bottomSheetWorkspaceScale: 1.0
+	bottomSheetWorkspaceScale: 0.97
 	bottomSheetDepth: 0.0
 	allAppsShiftRange: 1080.0px (411.42856dp)
 	allAppsOpenDuration: 600
diff --git a/tests/assets/dumpTests/DeviceProfileDumpTest/phoneVerticalBar3Button.txt b/tests/assets/dumpTests/DeviceProfileDumpTest/phoneVerticalBar3Button.txt
index d107988..053dd62 100644
--- a/tests/assets/dumpTests/DeviceProfileDumpTest/phoneVerticalBar3Button.txt
+++ b/tests/assets/dumpTests/DeviceProfileDumpTest/phoneVerticalBar3Button.txt
@@ -53,7 +53,7 @@
 	bottomSheetTopPadding: 114.0px (43.42857dp)
 	bottomSheetOpenDuration: 267
 	bottomSheetCloseDuration: 267
-	bottomSheetWorkspaceScale: 1.0
+	bottomSheetWorkspaceScale: 0.97
 	bottomSheetDepth: 0.0
 	allAppsShiftRange: 1080.0px (411.42856dp)
 	allAppsOpenDuration: 600
diff --git a/tests/multivalentTests/src/com/android/launcher3/AbstractDeviceProfileTest.kt b/tests/multivalentTests/src/com/android/launcher3/AbstractDeviceProfileTest.kt
index a30261e..dc49ba0 100644
--- a/tests/multivalentTests/src/com/android/launcher3/AbstractDeviceProfileTest.kt
+++ b/tests/multivalentTests/src/com/android/launcher3/AbstractDeviceProfileTest.kt
@@ -39,7 +39,6 @@
 import com.android.launcher3.util.SandboxContext
 import com.android.launcher3.util.WindowBounds
 import com.android.launcher3.util.rule.TestStabilityRule
-import com.android.launcher3.util.rule.ZipFilesRule
 import com.android.launcher3.util.rule.setFlags
 import com.android.launcher3.util.window.CachedDisplayInfo
 import com.android.launcher3.util.window.WindowManagerProxy
@@ -52,7 +51,6 @@
 import java.io.StringWriter
 import kotlin.math.max
 import kotlin.math.min
-import org.junit.ClassRule
 import org.junit.Rule
 import org.mockito.kotlin.any
 import org.mockito.kotlin.doReturn
@@ -82,13 +80,6 @@
 
     @Rule @JvmField val limitDevicesRule = LimitDevicesRule()
 
-    companion object {
-        @ClassRule
-        @JvmField
-        val resultZipRule =
-            ZipFilesRule(InstrumentationRegistry.getInstrumentation().targetContext, "DumpTest")
-    }
-
     class DeviceSpec(
         val naturalSize: Pair<Int, Int>,
         var densityDpi: Int,
@@ -375,7 +366,6 @@
     private fun writeToDevice(context: Context, fileName: String, content: String) {
         val file = File(context.getDir("dumpTests", Context.MODE_PRIVATE), fileName)
         file.writeText(content)
-        resultZipRule.write(file)
     }
 
     protected fun Float.dpToPx(): Float {
diff --git a/tests/multivalentTests/src/com/android/launcher3/celllayout/FavoriteItemsTransaction.java b/tests/multivalentTests/src/com/android/launcher3/celllayout/FavoriteItemsTransaction.java
index 47110fa..f772339 100644
--- a/tests/multivalentTests/src/com/android/launcher3/celllayout/FavoriteItemsTransaction.java
+++ b/tests/multivalentTests/src/com/android/launcher3/celllayout/FavoriteItemsTransaction.java
@@ -15,7 +15,6 @@
  */
 package com.android.launcher3.celllayout;
 
-import static com.android.launcher3.LauncherSettings.Favorites.TABLE_NAME;
 import static com.android.launcher3.util.Executors.MAIN_EXECUTOR;
 import static com.android.launcher3.util.Executors.MODEL_EXECUTOR;
 import static com.android.launcher3.util.TestUtil.runOnExecutorSync;
@@ -89,7 +88,7 @@
 
                     item.onAddToDatabase(writer);
                     writer.put(LauncherSettings.Favorites._ID, i);
-                    controller.insert(TABLE_NAME, writer.getValues(mContext));
+                    controller.insert(writer.getValues(mContext));
                 }
 
                 for (int i = 0; i < containerItems.size(); i++) {
@@ -97,7 +96,7 @@
                     ItemInfo item = containerItems.get(i);
                     item.onAddToDatabase(writer);
                     writer.put(LauncherSettings.Favorites._ID, count + i);
-                    controller.insert(TABLE_NAME, writer.getValues(mContext));
+                    controller.insert(writer.getValues(mContext));
                 }
                 transaction.commit();
             }
diff --git a/tests/multivalentTests/src/com/android/launcher3/celllayout/board/TestWorkspaceBuilder.kt b/tests/multivalentTests/src/com/android/launcher3/celllayout/board/TestWorkspaceBuilder.kt
index 2e556e8..3405cae 100644
--- a/tests/multivalentTests/src/com/android/launcher3/celllayout/board/TestWorkspaceBuilder.kt
+++ b/tests/multivalentTests/src/com/android/launcher3/celllayout/board/TestWorkspaceBuilder.kt
@@ -44,7 +44,7 @@
     private fun fillWithWidgets(
         widgetRect: WidgetRect,
         transaction: FavoriteItemsTransaction,
-        screenId: Int
+        screenId: Int,
     ): FavoriteItemsTransaction {
         val initX = widgetRect.cellX
         val initY = widgetRect.cellY
@@ -76,7 +76,7 @@
         appComponentName =
             ComponentName(
                 InstrumentationRegistry.getInstrumentation().context.packageName,
-                TEST_ACTIVITY_PACKAGE_PREFIX + testAppName
+                TEST_ACTIVITY_PACKAGE_PREFIX + testAppName,
             )
     }
 
@@ -92,7 +92,7 @@
     private fun addCorrespondingWidgetRect(
         widgetRect: WidgetRect,
         transaction: FavoriteItemsTransaction,
-        screenId: Int
+        screenId: Int,
     ) {
         if (widgetRect.type == 'x') {
             fillWithWidgets(widgetRect, transaction, screenId)
@@ -105,7 +105,7 @@
     fun buildFromBoard(
         board: CellLayoutBoard,
         transaction: FavoriteItemsTransaction,
-        screenId: Int
+        screenId: Int,
     ): FavoriteItemsTransaction {
         board.widgets.forEach { addCorrespondingWidgetRect(it, transaction, screenId) }
         board.icons.forEach { transaction.addItem { createIconInCell(it, screenId) } }
@@ -130,7 +130,7 @@
             WidgetUtils.createWidgetInfo(
                     TestViewHelpers.findWidgetProvider(false),
                     ApplicationProvider.getApplicationContext(),
-                    true
+                    true,
                 )
                 .apply {
                     cellX = widgetRect.cellX
@@ -154,7 +154,7 @@
             minSpanY = 1
             setOption(FolderInfo.FLAG_MULTI_PAGE_ANIMATION, true, null)
             for (i in 0 until folderPoint.numberIconsInside) {
-                add(getDefaultWorkspaceItem(paramScreenId), false)
+                add(getDefaultWorkspaceItem(paramScreenId))
             }
         }
 
diff --git a/tests/multivalentTests/src/com/android/launcher3/folder/FolderTest.kt b/tests/multivalentTests/src/com/android/launcher3/folder/FolderTest.kt
index bcf5f0d..e825995 100644
--- a/tests/multivalentTests/src/com/android/launcher3/folder/FolderTest.kt
+++ b/tests/multivalentTests/src/com/android/launcher3/folder/FolderTest.kt
@@ -298,12 +298,13 @@
         val dragObject = DragObject(context)
         dragObject.dragInfo = Mockito.mock(ItemInfo::class.java)
         folder.mContent = Mockito.mock(FolderPagedView::class.java)
+        folder.mFolderIcon = Mockito.mock(FolderIcon::class.java)
         dragObject.dragSource = folder
 
         folder.onDragStart(dragObject, DragOptions())
 
         verify(folder.mContent, times(1)).removeItem(folder.currentDragView)
-        verify(folder.mInfo, times(1)).remove(dragObject.dragInfo, true)
+        verify(folder, times(1)).removeFolderContent(true, dragObject.dragInfo)
         assertTrue(folder.itemsInvalidated)
         assertTrue(folder.isDragInProgress)
         assertFalse(folder.itemAddedBackToSelfViaIcon)
@@ -827,19 +828,19 @@
 
     @Test
     fun `onRemove should call removeItem with the correct views`() {
+        val folderInfo =
+            workspaceBuilder.createFolderInCell(FolderPoint(Point(1, 0), TWO_ICON_FOLDER_TYPE), 0)
+        val items = folderInfo.getContents().toTypedArray()
+        folder.mInfo = folderInfo
+        folder.mFolderIcon = Mockito.mock(FolderIcon::class.java)
         folder.mContent = Mockito.mock(FolderPagedView::class.java)
-        val items =
-            arrayListOf<ItemInfo>(
-                Mockito.mock(ItemInfo::class.java),
-                Mockito.mock(ItemInfo::class.java),
-            )
         val view1 = Mockito.mock(View::class.java)
         val view2 = Mockito.mock(View::class.java)
         doReturn(view1).whenever(folder).getViewForInfo(items[0])
         doReturn(view2).whenever(folder).getViewForInfo(items[1])
         doReturn(2).whenever(folder).itemCount
 
-        folder.onRemove(items)
+        folder.removeFolderContent(false, *items)
 
         verify(folder.mContent, times(1)).removeItem(view1)
         verify(folder.mContent, times(1)).removeItem(view2)
@@ -847,20 +848,20 @@
 
     @Test
     fun `onRemove should set mRearrangeOnClose to true and not call rearrangeChildren if animating`() {
+        val folderInfo =
+            workspaceBuilder.createFolderInCell(FolderPoint(Point(1, 0), TWO_ICON_FOLDER_TYPE), 0)
+        val items = folderInfo.getContents().toTypedArray()
+        folder.mInfo = folderInfo
+        folder.mFolderIcon = Mockito.mock(FolderIcon::class.java)
         folder.mContent = Mockito.mock(FolderPagedView::class.java)
         folder.state = STATE_ANIMATING
-        val items =
-            arrayListOf<ItemInfo>(
-                Mockito.mock(ItemInfo::class.java),
-                Mockito.mock(ItemInfo::class.java),
-            )
         val view1 = Mockito.mock(View::class.java)
         val view2 = Mockito.mock(View::class.java)
         doReturn(view1).whenever(folder).getViewForInfo(items[0])
         doReturn(view2).whenever(folder).getViewForInfo(items[1])
         doReturn(2).whenever(folder).itemCount
 
-        folder.onRemove(items)
+        folder.removeFolderContent(true, *items)
 
         assertTrue(folder.rearrangeOnClose)
         verify(folder, times(0)).rearrangeChildren()
@@ -868,21 +869,21 @@
 
     @Test
     fun `onRemove should set not change mRearrangeOnClose and not call rearrangeChildren if not animating`() {
+        val folderInfo =
+            workspaceBuilder.createFolderInCell(FolderPoint(Point(1, 0), TWO_ICON_FOLDER_TYPE), 0)
+        val items = folderInfo.getContents().toTypedArray()
+        folder.mInfo = folderInfo
+        folder.mFolderIcon = Mockito.mock(FolderIcon::class.java)
         folder.mContent = Mockito.mock(FolderPagedView::class.java)
         folder.state = STATE_CLOSED
         folder.rearrangeOnClose = false
-        val items =
-            arrayListOf<ItemInfo>(
-                Mockito.mock(ItemInfo::class.java),
-                Mockito.mock(ItemInfo::class.java),
-            )
         val view1 = Mockito.mock(View::class.java)
         val view2 = Mockito.mock(View::class.java)
         doReturn(view1).whenever(folder).getViewForInfo(items[0])
         doReturn(view2).whenever(folder).getViewForInfo(items[1])
         doReturn(2).whenever(folder).itemCount
 
-        folder.onRemove(items)
+        folder.removeFolderContent(false, *items)
 
         assertFalse(folder.rearrangeOnClose)
         verify(folder, times(1)).rearrangeChildren()
@@ -890,12 +891,12 @@
 
     @Test
     fun `onRemove should call close if mIsOpen is true and item count is less than or equal to one`() {
+        val folderInfo =
+            workspaceBuilder.createFolderInCell(FolderPoint(Point(1, 0), TWO_ICON_FOLDER_TYPE), 0)
+        val items = folderInfo.getContents().toTypedArray()
+        folder.mInfo = folderInfo
+        folder.mFolderIcon = Mockito.mock(FolderIcon::class.java)
         folder.mContent = Mockito.mock(FolderPagedView::class.java)
-        val items =
-            arrayListOf<ItemInfo>(
-                Mockito.mock(ItemInfo::class.java),
-                Mockito.mock(ItemInfo::class.java),
-            )
         val view1 = Mockito.mock(View::class.java)
         val view2 = Mockito.mock(View::class.java)
         doReturn(view1).whenever(folder).getViewForInfo(items[0])
@@ -904,19 +905,19 @@
         folder.setIsOpen(true)
         doNothing().`when`(folder).close(true)
 
-        folder.onRemove(items)
+        folder.removeFolderContent(false, *items)
 
         verify(folder, times(1)).close(true)
     }
 
     @Test
     fun `onRemove should call replaceFolderWithFinalItem if mIsOpen is false and item count is less than or equal to one`() {
+        val folderInfo =
+            workspaceBuilder.createFolderInCell(FolderPoint(Point(1, 0), TWO_ICON_FOLDER_TYPE), 0)
+        val items = folderInfo.getContents().toTypedArray()
+        folder.mInfo = folderInfo
+        folder.mFolderIcon = Mockito.mock(FolderIcon::class.java)
         folder.mContent = Mockito.mock(FolderPagedView::class.java)
-        val items =
-            arrayListOf<ItemInfo>(
-                Mockito.mock(ItemInfo::class.java),
-                Mockito.mock(ItemInfo::class.java),
-            )
         val view1 = Mockito.mock(View::class.java)
         val view2 = Mockito.mock(View::class.java)
         doReturn(view1).whenever(folder).getViewForInfo(items[0])
@@ -924,7 +925,7 @@
         doReturn(1).whenever(folder).itemCount
         folder.setIsOpen(false)
 
-        folder.onRemove(items)
+        folder.removeFolderContent(false, *items)
 
         verify(folder, times(1)).replaceFolderWithFinalItem()
     }
diff --git a/tests/multivalentTests/src/com/android/launcher3/model/AddWorkspaceItemsTaskTest.kt b/tests/multivalentTests/src/com/android/launcher3/model/AddWorkspaceItemsTaskTest.kt
index 08b8f81..25f4cf1 100644
--- a/tests/multivalentTests/src/com/android/launcher3/model/AddWorkspaceItemsTaskTest.kt
+++ b/tests/multivalentTests/src/com/android/launcher3/model/AddWorkspaceItemsTaskTest.kt
@@ -33,7 +33,6 @@
 import org.mockito.kotlin.any
 import org.mockito.kotlin.eq
 import org.mockito.kotlin.mock
-import org.mockito.kotlin.same
 import org.mockito.kotlin.verify
 import org.mockito.kotlin.verifyNoMoreInteractions
 import org.mockito.kotlin.whenever
@@ -142,10 +141,9 @@
     /** Sets up the item space data that will be returned from WorkspaceItemSpaceFinder. */
     private fun givenNewItemSpaces(vararg newItemSpaces: NewItemSpace) {
         val spaceStack = newItemSpaces.toMutableList()
-        whenever(
-                mWorkspaceItemSpaceFinder.findSpaceForItem(any(), any(), any(), any(), any(), any())
-            )
-            .then { spaceStack.removeFirst().toIntArray() }
+        whenever(mWorkspaceItemSpaceFinder.findSpaceForItem(any(), any(), any(), any())).then {
+            spaceStack.removeFirst().toIntArray()
+        }
     }
 
     /**
@@ -155,8 +153,6 @@
     private fun verifyItemSpaceFinderCall(nonEmptyScreenIds: List<Int>, numberOfExpectedCall: Int) {
         verify(mWorkspaceItemSpaceFinder, times(numberOfExpectedCall))
             .findSpaceForItem(
-                eq(mAppState),
-                same(mModelHelper.bgDataModel),
                 eq(IntArray.wrap(*nonEmptyScreenIds.toIntArray())),
                 eq(IntArray()),
                 eq(1),
diff --git a/tests/multivalentTests/src/com/android/launcher3/model/DatabaseHelperTest.kt b/tests/multivalentTests/src/com/android/launcher3/model/DatabaseHelperTest.kt
index 09752b8..89e676f 100644
--- a/tests/multivalentTests/src/com/android/launcher3/model/DatabaseHelperTest.kt
+++ b/tests/multivalentTests/src/com/android/launcher3/model/DatabaseHelperTest.kt
@@ -11,6 +11,7 @@
 import com.android.launcher3.LauncherSettings.Favorites.addTableToDb
 import com.android.launcher3.pm.UserCache
 import com.android.launcher3.provider.LauncherDbUtils
+import com.android.launcher3.util.ModelTestExtensions
 import java.util.function.ToLongFunction
 import org.junit.After
 import org.junit.Assert.assertEquals
@@ -33,7 +34,7 @@
 
     @Before
     fun setUp() {
-        db = FactitiousDbController(context, INSERTION_SQL).inMemoryDb
+        db = ModelTestExtensions.createInMemoryDb(INSERTION_SQL)
     }
 
     @After
diff --git a/tests/multivalentTests/src/com/android/launcher3/model/FactitiousDbController.kt b/tests/multivalentTests/src/com/android/launcher3/model/FactitiousDbController.kt
deleted file mode 100644
index 711e1d2..0000000
--- a/tests/multivalentTests/src/com/android/launcher3/model/FactitiousDbController.kt
+++ /dev/null
@@ -1,60 +0,0 @@
-package com.android.launcher3.model
-
-import android.content.Context
-import android.database.Cursor
-import android.database.sqlite.SQLiteDatabase
-import androidx.test.platform.app.InstrumentationRegistry
-import java.io.BufferedReader
-import java.io.InputStreamReader
-
-private val All_COLUMNS =
-    arrayOf(
-        "_id",
-        "title",
-        "intent",
-        "container",
-        "screen",
-        "cellX",
-        "cellY",
-        "spanX",
-        "spanY",
-        "itemType",
-        "appWidgetId",
-        "icon",
-        "appWidgetProvider",
-        "modified",
-        "restored",
-        "profileId",
-        "rank",
-        "options",
-        "appWidgetSource"
-    )
-
-class FactitiousDbController(context: Context, insertFile: String) : ModelDbController(context) {
-
-    val inMemoryDb: SQLiteDatabase by lazy {
-        SQLiteDatabase.createInMemory(SQLiteDatabase.OpenParams.Builder().build()).also { db ->
-            BufferedReader(
-                    InputStreamReader(
-                        InstrumentationRegistry.getInstrumentation().context.assets.open(insertFile)
-                    )
-                )
-                .lines()
-                .forEach { sqlStatement -> db.execSQL(sqlStatement) }
-        }
-    }
-
-    override fun query(
-        table: String,
-        projection: Array<out String>?,
-        selection: String?,
-        selectionArgs: Array<out String>?,
-        sortOrder: String?
-    ): Cursor {
-        return inMemoryDb.query(table, All_COLUMNS, selection, selectionArgs, null, null, sortOrder)
-    }
-
-    override fun loadDefaultFavoritesIfNecessary() {
-        // No-Op
-    }
-}
diff --git a/tests/multivalentTests/src/com/android/launcher3/model/LoaderCursorTest.java b/tests/multivalentTests/src/com/android/launcher3/model/LoaderCursorTest.java
index ad40818..b848d27 100644
--- a/tests/multivalentTests/src/com/android/launcher3/model/LoaderCursorTest.java
+++ b/tests/multivalentTests/src/com/android/launcher3/model/LoaderCursorTest.java
@@ -55,7 +55,6 @@
 import static junit.framework.Assert.assertTrue;
 
 import android.content.ComponentName;
-import android.content.Context;
 import android.content.Intent;
 import android.database.MatrixCursor;
 import android.graphics.Bitmap;
@@ -76,6 +75,7 @@
 import com.android.launcher3.model.data.WorkspaceItemInfo;
 import com.android.launcher3.util.Executors;
 import com.android.launcher3.util.LauncherModelHelper;
+import com.android.launcher3.util.LauncherModelHelper.SandboxModelContext;
 import com.android.launcher3.util.PackageManagerHelper;
 
 import org.junit.After;
@@ -96,11 +96,10 @@
 
     private LauncherModelHelper mModelHelper;
     private LauncherAppState mApp;
-    private PackageManagerHelper mPmHelper;
 
     private MatrixCursor mCursor;
     private InvariantDeviceProfile mIDP;
-    private Context mContext;
+    private SandboxModelContext mContext;
 
     private LoaderCursor mLoaderCursor;
 
@@ -116,7 +115,6 @@
         mContext = mModelHelper.sandboxContext;
         mIDP = InvariantDeviceProfile.INSTANCE.get(mContext);
         mApp = LauncherAppState.getInstance(mContext);
-        mPmHelper = PackageManagerHelper.INSTANCE.get(mContext);
 
         mCursor = new MatrixCursor(new String[] {
                 ICON, TITLE, _ID, CONTAINER, ITEM_TYPE,
@@ -126,7 +124,8 @@
         });
 
         UserManagerState ums = new UserManagerState();
-        mLoaderCursor = new LoaderCursor(mCursor, mApp, ums, mPmHelper, null);
+        mLoaderCursor = mContext.getAppComponent().getLoaderCursorFactory()
+                .createLoaderCursor(mCursor, ums, null);
         ums.allUsers.put(0, Process.myUserHandle());
     }
 
diff --git a/tests/multivalentTests/src/com/android/launcher3/model/PackageUpdatedTaskTest.kt b/tests/multivalentTests/src/com/android/launcher3/model/PackageUpdatedTaskTest.kt
index eec6eed..5fd93d1 100644
--- a/tests/multivalentTests/src/com/android/launcher3/model/PackageUpdatedTaskTest.kt
+++ b/tests/multivalentTests/src/com/android/launcher3/model/PackageUpdatedTaskTest.kt
@@ -27,8 +27,9 @@
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import com.android.launcher3.AppFilter
 import com.android.launcher3.Flags.FLAG_ENABLE_PRIVATE_SPACE
-import com.android.launcher3.LauncherAppState
 import com.android.launcher3.LauncherSettings
+import com.android.launcher3.dagger.LauncherAppComponent
+import com.android.launcher3.dagger.LauncherAppSingleton
 import com.android.launcher3.icons.IconCache
 import com.android.launcher3.model.PackageUpdatedTask.OP_ADD
 import com.android.launcher3.model.PackageUpdatedTask.OP_REMOVE
@@ -39,17 +40,20 @@
 import com.android.launcher3.model.PackageUpdatedTask.OP_USER_AVAILABILITY_CHANGE
 import com.android.launcher3.model.data.AppInfo
 import com.android.launcher3.model.data.WorkspaceItemInfo
+import com.android.launcher3.util.AllModulesForTest
 import com.android.launcher3.util.Executors
 import com.android.launcher3.util.LauncherModelHelper
-import com.android.launcher3.util.LauncherModelHelper.SandboxModelContext
 import com.android.launcher3.util.TestUtil
 import com.google.common.truth.Truth.assertThat
+import dagger.BindsInstance
+import dagger.Component
 import org.junit.After
 import org.junit.Before
 import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.mockito.kotlin.any
+import org.mockito.kotlin.doAnswer
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.spy
 import org.mockito.kotlin.verify
@@ -61,10 +65,8 @@
     @get:Rule val setFlagsRule = SetFlagsRule()
 
     private val mUser = myUserHandle()
-    private val mDataModel: BgDataModel = BgDataModel()
     private val mLauncherModelHelper = LauncherModelHelper()
-    private val mContext: SandboxModelContext = spy(mLauncherModelHelper.sandboxContext)
-    private val mAppState: LauncherAppState = spy(LauncherAppState.getInstance(mContext))
+    private val mContext = mLauncherModelHelper.sandboxContext
 
     private val expectedPackage = "Test.Package"
     private val expectedComponent = ComponentName(expectedPackage, "TestClass")
@@ -72,22 +74,33 @@
     private val expectedWorkspaceItem = spy(WorkspaceItemInfo())
 
     private val mockIconCache: IconCache = mock()
-    private val mockTaskController: ModelTaskController = mock<ModelTaskController>()
     private val mockAppFilter: AppFilter = mock<AppFilter>()
+    private lateinit var mAllAppsList: AllAppsList
+
     private val mockApplicationInfo: ApplicationInfo = mock<ApplicationInfo>()
     private val mockActivityInfo: ActivityInfo = mock<ActivityInfo>()
 
-    private lateinit var mAllAppsList: AllAppsList
+    private lateinit var mDataModel: BgDataModel
+    private lateinit var mockTaskController: ModelTaskController
 
     @Before
     fun setup() {
         mAllAppsList = spy(AllAppsList(mockIconCache, mockAppFilter))
-        mLauncherModelHelper.sandboxContext.spyService(LauncherApps::class.java).apply {
+        mContext.initDaggerComponent(
+            DaggerPackageUpdatedTaskTest_TestComponent.builder()
+                .bindAllAppsList(mAllAppsList)
+                .bindAppFilter(mockAppFilter)
+                .bindIconCache(mockIconCache)
+        )
+
+        mContext.spyService(LauncherApps::class.java).apply {
             whenever(getActivityList(expectedPackage, mUser))
                 .thenReturn(listOf(expectedActivityInfo))
         }
-        whenever(mAppState.iconCache).thenReturn(mockIconCache)
-        whenever(mockTaskController.app).thenReturn(mAppState)
+
+        mockTaskController = spy((mContext.appComponent as TestComponent).getTaskController())
+        mDataModel = (mContext.appComponent as TestComponent).getDataModel()
+
         whenever(mockAppFilter.shouldShowApp(expectedComponent)).thenReturn(true)
         mockApplicationInfo.apply {
             uid = 1
@@ -122,7 +135,6 @@
         TestUtil.runOnExecutorSync(Executors.MODEL_EXECUTOR) {
             taskUnderTest.execute(mockTaskController, mDataModel, mAllAppsList)
         }
-        mLauncherModelHelper.loadModelSync()
         // Then
         verify(mockIconCache).updateIconsForPkg(expectedPackage, mUser)
         verify(mAllAppsList).addPackage(mContext, expectedPackage, mUser)
@@ -141,7 +153,6 @@
         TestUtil.runOnExecutorSync(Executors.MODEL_EXECUTOR) {
             taskUnderTest.execute(mockTaskController, mDataModel, mAllAppsList)
         }
-        mLauncherModelHelper.loadModelSync()
         // Then
         verify(mockIconCache).updateIconsForPkg(expectedPackage, mUser)
         verify(mAllAppsList).updatePackage(mContext, expectedPackage, mUser)
@@ -159,7 +170,6 @@
         TestUtil.runOnExecutorSync(Executors.MODEL_EXECUTOR) {
             taskUnderTest.execute(mockTaskController, mDataModel, mAllAppsList)
         }
-        mLauncherModelHelper.loadModelSync()
         // Then
         verify(mockIconCache).removeIconsForPkg(expectedPackage, mUser)
         verify(mAllAppsList).removePackage(expectedPackage, mUser)
@@ -176,7 +186,6 @@
         TestUtil.runOnExecutorSync(Executors.MODEL_EXECUTOR) {
             taskUnderTest.execute(mockTaskController, mDataModel, mAllAppsList)
         }
-        mLauncherModelHelper.loadModelSync()
         // Then
         verify(mAllAppsList).removePackage(expectedPackage, mUser)
         verify(mockTaskController).bindUpdatedWorkspaceItems(listOf(expectedWorkspaceItem))
@@ -190,10 +199,11 @@
         // When
         mDataModel.addItem(mContext, expectedWorkspaceItem, true)
         mAllAppsList.add(AppInfo(mContext, expectedActivityInfo, mUser), expectedActivityInfo)
+        mAllAppsList.getAndResetChangeFlag()
+        doAnswer {}.whenever(mockTaskController).bindApplicationsIfNeeded()
         TestUtil.runOnExecutorSync(Executors.MODEL_EXECUTOR) {
             taskUnderTest.execute(mockTaskController, mDataModel, mAllAppsList)
         }
-        mLauncherModelHelper.loadModelSync()
         // Then
         verify(mAllAppsList).updateDisabledFlags(any(), any())
         verify(mockTaskController).bindUpdatedWorkspaceItems(listOf(expectedWorkspaceItem))
@@ -206,10 +216,11 @@
         val taskUnderTest = PackageUpdatedTask(OP_UNSUSPEND, mUser, expectedPackage)
         // When
         mDataModel.addItem(mContext, expectedWorkspaceItem, true)
+        mAllAppsList.getAndResetChangeFlag()
+        doAnswer {}.whenever(mockTaskController).bindApplicationsIfNeeded()
         TestUtil.runOnExecutorSync(Executors.MODEL_EXECUTOR) {
             taskUnderTest.execute(mockTaskController, mDataModel, mAllAppsList)
         }
-        mLauncherModelHelper.loadModelSync()
         // Then
         verify(mAllAppsList).updateDisabledFlags(any(), any())
         verify(mockTaskController).bindUpdatedWorkspaceItems(emptyList())
@@ -226,10 +237,29 @@
         TestUtil.runOnExecutorSync(Executors.MODEL_EXECUTOR) {
             taskUnderTest.execute(mockTaskController, mDataModel, mAllAppsList)
         }
-        mLauncherModelHelper.loadModelSync()
         // Then
         verify(mAllAppsList).updateDisabledFlags(any(), any())
         verify(mockTaskController).bindUpdatedWorkspaceItems(emptyList())
         assertThat(mAllAppsList.data).isEmpty()
     }
+
+    @LauncherAppSingleton
+    @Component(modules = [AllModulesForTest::class])
+    interface TestComponent : LauncherAppComponent {
+
+        fun getDataModel(): BgDataModel
+
+        fun getTaskController(): ModelTaskController
+
+        @Component.Builder
+        interface Builder : LauncherAppComponent.Builder {
+            @BindsInstance fun bindAppFilter(appFilter: AppFilter): Builder
+
+            @BindsInstance fun bindIconCache(iconCache: IconCache): Builder
+
+            @BindsInstance fun bindAllAppsList(list: AllAppsList): Builder
+
+            override fun build(): TestComponent
+        }
+    }
 }
diff --git a/tests/multivalentTests/src/com/android/launcher3/model/ShortcutsChangedTaskTest.kt b/tests/multivalentTests/src/com/android/launcher3/model/ShortcutsChangedTaskTest.kt
index c6863f4..0ab736b 100644
--- a/tests/multivalentTests/src/com/android/launcher3/model/ShortcutsChangedTaskTest.kt
+++ b/tests/multivalentTests/src/com/android/launcher3/model/ShortcutsChangedTaskTest.kt
@@ -30,7 +30,6 @@
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import androidx.test.filters.SmallTest
 import com.android.launcher3.Flags
-import com.android.launcher3.LauncherAppState
 import com.android.launcher3.LauncherSettings.Favorites.ITEM_TYPE_DEEP_SHORTCUT
 import com.android.launcher3.icons.BitmapInfo
 import com.android.launcher3.icons.CacheableShortcutInfo
@@ -73,7 +72,6 @@
     private val user: UserHandle = myUserHandle()
     private val mockTaskController: ModelTaskController = mock()
     private val mockAllApps: AllAppsList = mock()
-    private val mockAppState: LauncherAppState = mock()
     private val mockIconCache: IconCache = mock()
 
     private val expectedWai =
@@ -93,9 +91,8 @@
         modelHelper.loadModelSync()
         context = modelHelper.sandboxContext
         launcherApps = context.spyService(LauncherApps::class.java)
-        whenever(mockTaskController.app).thenReturn(mockAppState)
-        whenever(mockAppState.context).thenReturn(context)
-        whenever(mockAppState.iconCache).thenReturn(mockIconCache)
+        whenever(mockTaskController.context).thenReturn(context)
+        whenever(mockTaskController.iconCache).thenReturn(mockIconCache)
         whenever(mockIconCache.getShortcutIcon(eq(expectedWai), any<CacheableShortcutInfo>()))
             .then { _ -> { expectedWai.bitmap = BitmapInfo.LOW_RES_INFO } }
         shortcuts = emptyList()
@@ -132,8 +129,7 @@
         // When
         shortcutsChangedTask.execute(mockTaskController, modelHelper.bgDataModel, mockAllApps)
         // Then
-        verify(mockAppState.iconCache)
-            .getShortcutIcon(eq(expectedWai), any<CacheableShortcutInfo>())
+        verify(mockIconCache).getShortcutIcon(eq(expectedWai), any<CacheableShortcutInfo>())
         verify(mockTaskController).bindUpdatedWorkspaceItems(listOf(expectedWai))
     }
 
@@ -196,8 +192,7 @@
         // When
         shortcutsChangedTask.execute(mockTaskController, modelHelper.bgDataModel, mockAllApps)
         // Then
-        verify(mockAppState.iconCache)
-            .getShortcutIcon(eq(expectedWai), any<CacheableShortcutInfo>())
+        verify(mockIconCache).getShortcutIcon(eq(expectedWai), any<CacheableShortcutInfo>())
         verify(mockTaskController).bindUpdatedWorkspaceItems(listOf(expectedWai))
     }
 
@@ -256,8 +251,7 @@
         // When
         shortcutsChangedTask.execute(mockTaskController, modelHelper.bgDataModel, mockAllApps)
         // Then
-        verify(mockAppState.iconCache)
-            .getShortcutIcon(eq(expectedWai), any<CacheableShortcutInfo>())
+        verify(mockIconCache).getShortcutIcon(eq(expectedWai), any<CacheableShortcutInfo>())
         verify(mockTaskController).bindUpdatedWorkspaceItems(listOf(expectedWai))
     }
 
@@ -287,8 +281,7 @@
         // When
         shortcutsChangedTask.execute(mockTaskController, modelHelper.bgDataModel, mockAllApps)
         // Then
-        verify(mockAppState.iconCache)
-            .getShortcutIcon(eq(expectedWai), any<CacheableShortcutInfo>())
+        verify(mockIconCache).getShortcutIcon(eq(expectedWai), any<CacheableShortcutInfo>())
         verify(mockTaskController).bindUpdatedWorkspaceItems(listOf(expectedWai))
     }
 
diff --git a/tests/multivalentTests/src/com/android/launcher3/model/WidgetsModelTest.kt b/tests/multivalentTests/src/com/android/launcher3/model/WidgetsModelTest.kt
index 777d81b..2e6ecc5 100644
--- a/tests/multivalentTests/src/com/android/launcher3/model/WidgetsModelTest.kt
+++ b/tests/multivalentTests/src/com/android/launcher3/model/WidgetsModelTest.kt
@@ -25,9 +25,9 @@
 import android.platform.test.rule.LimitDevicesRule
 import androidx.test.core.app.ApplicationProvider
 import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.android.launcher3.AppFilter
 import com.android.launcher3.DeviceProfile
 import com.android.launcher3.InvariantDeviceProfile
-import com.android.launcher3.LauncherAppState
 import com.android.launcher3.icons.IconCache
 import com.android.launcher3.model.data.PackageItemInfo
 import com.android.launcher3.pm.UserCache
@@ -62,7 +62,6 @@
     @Rule @JvmField val mockitoRule: MockitoRule = MockitoJUnit.rule()
 
     @Mock private lateinit var appWidgetManager: AppWidgetManager
-    @Mock private lateinit var app: LauncherAppState
     @Mock private lateinit var iconCacheMock: IconCache
 
     private lateinit var context: Context
@@ -93,9 +92,6 @@
 
         whenever(iconCacheMock.getTitleNoCache(any<LauncherAppWidgetProviderInfo>()))
             .thenReturn("title")
-        whenever(app.iconCache).thenReturn(iconCacheMock)
-        whenever(app.context).thenReturn(context)
-        whenever(app.invariantDeviceProfile).thenReturn(idp)
 
         val widgetToCategoryEntry: Map.Entry<ComponentName, IntSet> =
             WidgetSections.getWidgetsToCategory(context).entries.first()
@@ -128,7 +124,7 @@
         val userCache = spy(UserCache.INSTANCE.get(context))
         whenever(userCache.userProfiles).thenReturn(listOf(UserHandle.CURRENT))
 
-        underTest = WidgetsModel()
+        underTest = WidgetsModel(context, idp, iconCacheMock, AppFilter(context))
     }
 
     @Test
@@ -237,7 +233,7 @@
                     update = false
                     // Similarly, model could update its code independently while a client is
                     // iterating on the list.
-                    underTest.update(app, /* packageUser= */ null)
+                    underTest.update(/* packageUser= */ null)
                 }
             }
 
@@ -253,7 +249,7 @@
     private fun loadWidgets() {
         val latch = CountDownLatch(1)
         Executors.MODEL_EXECUTOR.execute {
-            underTest.update(app, /* packageUser= */ null)
+            underTest.update(/* packageUser= */ null)
             latch.countDown()
         }
         if (!latch.await(LOAD_WIDGETS_TIMEOUT_SECONDS, TimeUnit.SECONDS)) {
diff --git a/tests/multivalentTests/src/com/android/launcher3/model/WorkspaceItemProcessorTest.kt b/tests/multivalentTests/src/com/android/launcher3/model/WorkspaceItemProcessorTest.kt
index a55d64b..cba7b88 100644
--- a/tests/multivalentTests/src/com/android/launcher3/model/WorkspaceItemProcessorTest.kt
+++ b/tests/multivalentTests/src/com/android/launcher3/model/WorkspaceItemProcessorTest.kt
@@ -31,7 +31,7 @@
 import android.util.LongSparseArray
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import com.android.launcher3.Flags
-import com.android.launcher3.LauncherAppState
+import com.android.launcher3.InvariantDeviceProfile
 import com.android.launcher3.LauncherSettings.Favorites
 import com.android.launcher3.LauncherSettings.Favorites.CONTAINER_DESKTOP
 import com.android.launcher3.LauncherSettings.Favorites.ITEM_TYPE_APPLICATION
@@ -41,6 +41,7 @@
 import com.android.launcher3.Utilities.EMPTY_PERSON_ARRAY
 import com.android.launcher3.backuprestore.LauncherRestoreEventLogger.RestoreError
 import com.android.launcher3.icons.CacheableShortcutInfo
+import com.android.launcher3.icons.IconCache
 import com.android.launcher3.model.data.FolderInfo
 import com.android.launcher3.model.data.IconRequestInfo
 import com.android.launcher3.model.data.ItemInfo
@@ -66,12 +67,14 @@
 import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
+import org.mockito.Answers
 import org.mockito.ArgumentCaptor
 import org.mockito.Mock
 import org.mockito.Mockito.RETURNS_DEEP_STUBS
 import org.mockito.Mockito.mock
 import org.mockito.Mockito.times
 import org.mockito.Mockito.verify
+import org.mockito.MockitoAnnotations
 import org.mockito.kotlin.any
 import org.mockito.kotlin.anyOrNull
 import org.mockito.kotlin.doAnswer
@@ -88,12 +91,12 @@
     @Mock private lateinit var mockIconRequestInfo: IconRequestInfo<WorkspaceItemInfo>
     @Mock private lateinit var mockWorkspaceInfo: WorkspaceItemInfo
     @Mock private lateinit var mockBgDataModel: BgDataModel
-    @Mock private lateinit var mockAppState: LauncherAppState
     @Mock private lateinit var mockPmHelper: PackageManagerHelper
-    @Mock private lateinit var mockCursor: LoaderCursor
+    @Mock(answer = Answers.RETURNS_DEEP_STUBS) private lateinit var mockCursor: LoaderCursor
     @Mock private lateinit var mockUserCache: UserCache
     @Mock private lateinit var mockUserManagerState: UserManagerState
     @Mock private lateinit var mockWidgetInflater: WidgetInflater
+    @Mock private lateinit var mockIconCache: IconCache
 
     lateinit var mModelHelper: LauncherModelHelper
     lateinit var mContext: SandboxModelContext
@@ -114,6 +117,7 @@
 
     @Before
     fun setup() {
+        MockitoAnnotations.initMocks(this)
         mModelHelper = LauncherModelHelper()
         mContext = mModelHelper.sandboxContext
         mLauncherApps =
@@ -122,9 +126,6 @@
                 doReturn(true).whenever(this).isActivityEnabled(mComponentName, mUserHandle)
             }
         mUserHandle = Process.myUserHandle()
-        mockIconRequestInfo = mock<IconRequestInfo<WorkspaceItemInfo>>()
-        mockWorkspaceInfo = mock<WorkspaceItemInfo>()
-        mockBgDataModel = mock<BgDataModel>()
         mComponentName = ComponentName("package", "class")
         mUnlockedUsersArray = LongSparseArray<Boolean>(1).apply { put(101, true) }
         mIntent =
@@ -133,40 +134,26 @@
                 `package` = "pkg"
                 putExtra(ShortcutKey.EXTRA_SHORTCUT_ID, "")
             }
-        mockAppState =
-            mock<LauncherAppState>().apply {
-                whenever(context).thenReturn(mContext)
-                whenever(iconCache).thenReturn(mock())
-                whenever(iconCache.getShortcutIcon(any(), any(), any())).then {}
-            }
-        mockPmHelper =
-            mock<PackageManagerHelper>().apply {
-                whenever(getAppLaunchIntent(mComponentName.packageName, mUserHandle))
-                    .thenReturn(mIntent)
-            }
-        mockCursor =
-            mock(LoaderCursor::class.java, RETURNS_DEEP_STUBS).apply {
-                user = mUserHandle
-                itemType = ITEM_TYPE_APPLICATION
-                id = 1
-                restoreFlag = 1
-                serialNumber = 101
-                whenever(parseIntent()).thenReturn(mIntent)
-                whenever(markRestored()).doAnswer { restoreFlag = 0 }
-                whenever(updater().put(Favorites.INTENT, mIntent.toUri(0)).commit()).thenReturn(1)
-                whenever(getAppShortcutInfo(any(), any(), any(), any()))
-                    .thenReturn(mockWorkspaceInfo)
-                whenever(createIconRequestInfo(any(), any())).thenReturn(mockIconRequestInfo)
-            }
-        mockUserCache =
-            mock<UserCache>().apply {
-                val userIconInfo =
-                    mock<UserIconInfo>().apply { whenever(isPrivate).thenReturn(false) }
-                whenever(getUserInfo(any())).thenReturn(userIconInfo)
-            }
+        whenever(mockIconCache.getShortcutIcon(any(), any(), any())).then {}
+        whenever(mockPmHelper.getAppLaunchIntent(mComponentName.packageName, mUserHandle))
+            .thenReturn(mIntent)
+        mockCursor.apply {
+            user = mUserHandle
+            itemType = ITEM_TYPE_APPLICATION
+            id = 1
+            restoreFlag = 1
+            serialNumber = 101
+            whenever(parseIntent()).thenReturn(mIntent)
+            whenever(markRestored()).doAnswer { restoreFlag = 0 }
+            whenever(updater().put(Favorites.INTENT, mIntent.toUri(0)).commit()).thenReturn(1)
+            whenever(getAppShortcutInfo(any(), any(), any(), any())).thenReturn(mockWorkspaceInfo)
+            whenever(createIconRequestInfo(any(), any())).thenReturn(mockIconRequestInfo)
+        }
+        mockUserCache.apply {
+            val userIconInfo = mock<UserIconInfo>().apply { whenever(isPrivate).thenReturn(false) }
+            whenever(getUserInfo(any())).thenReturn(userIconInfo)
+        }
 
-        mockUserManagerState = mock<UserManagerState>()
-        mockWidgetInflater = mock<WidgetInflater>()
         mKeyToPinnedShortcutsMap = mutableMapOf()
         mInstallingPkgs = hashMapOf()
         mAllDeepShortcuts = mutableListOf()
@@ -187,7 +174,6 @@
         userManagerState: UserManagerState = mockUserManagerState,
         launcherApps: LauncherApps = mLauncherApps,
         shortcutKeyToPinnedShortcuts: Map<ShortcutKey, ShortcutInfo> = mKeyToPinnedShortcutsMap,
-        app: LauncherAppState = mockAppState,
         bgDataModel: BgDataModel = mockBgDataModel,
         widgetProvidersMap: MutableMap<ComponentKey, AppWidgetProviderInfo?> = mWidgetProvidersMap,
         widgetInflater: WidgetInflater = mockWidgetInflater,
@@ -205,7 +191,7 @@
             userCache = userCache,
             userManagerState = userManagerState,
             launcherApps = launcherApps,
-            app = app,
+            context = mContext,
             bgDataModel = bgDataModel,
             widgetProvidersMap = widgetProvidersMap,
             widgetInflater = widgetInflater,
@@ -217,6 +203,9 @@
             shortcutKeyToPinnedShortcuts = shortcutKeyToPinnedShortcuts,
             installingPkgs = installingPkgs,
             allDeepShortcuts = allDeepShortcuts,
+            iconCache = mockIconCache,
+            idp = InvariantDeviceProfile.INSTANCE.get(mContext),
+            isSafeMode = false,
         )
 
     @Test
diff --git a/tests/multivalentTests/src/com/android/launcher3/model/WorkspaceItemSpaceFinderTest.kt b/tests/multivalentTests/src/com/android/launcher3/model/WorkspaceItemSpaceFinderTest.kt
index dd03eee..a18f93b 100644
--- a/tests/multivalentTests/src/com/android/launcher3/model/WorkspaceItemSpaceFinderTest.kt
+++ b/tests/multivalentTests/src/com/android/launcher3/model/WorkspaceItemSpaceFinderTest.kt
@@ -29,8 +29,6 @@
 @RunWith(AndroidJUnit4::class)
 class WorkspaceItemSpaceFinderTest : AbstractWorkspaceModelTest() {
 
-    private val mItemSpaceFinder = WorkspaceItemSpaceFinder()
-
     @Before
     override fun setup() {
         super.setup()
@@ -42,15 +40,12 @@
     }
 
     private fun findSpace(spanX: Int, spanY: Int): NewItemSpace =
-        mItemSpaceFinder
-            .findSpaceForItem(
-                mAppState,
+        WorkspaceItemSpaceFinder(
                 mModelHelper.bgDataModel,
-                mExistingScreens,
-                mNewScreens,
-                spanX,
-                spanY,
+                mAppState.invariantDeviceProfile,
+                mModelHelper.model,
             )
+            .findSpaceForItem(mExistingScreens, mNewScreens, spanX, spanY)
             .let { NewItemSpace.fromIntArray(it) }
 
     private fun assertRegionVacant(newItemSpace: NewItemSpace, spanX: Int, spanY: Int) {
diff --git a/tests/multivalentTests/src/com/android/launcher3/provider/RestoreDbTaskTest.java b/tests/multivalentTests/src/com/android/launcher3/provider/RestoreDbTaskTest.java
index c30b730..0f4940e 100644
--- a/tests/multivalentTests/src/com/android/launcher3/provider/RestoreDbTaskTest.java
+++ b/tests/multivalentTests/src/com/android/launcher3/provider/RestoreDbTaskTest.java
@@ -24,8 +24,6 @@
 import static com.android.launcher3.LauncherPrefs.RESTORE_DEVICE;
 import static com.android.launcher3.LauncherSettings.Favorites.CONTAINER_DESKTOP;
 import static com.android.launcher3.LauncherSettings.Favorites.ITEM_TYPE_APPLICATION;
-import static com.android.launcher3.LauncherSettings.Favorites.TABLE_NAME;
-import static com.android.launcher3.widget.LauncherWidgetHolder.APPWIDGET_HOST_ID;
 
 import static com.google.common.truth.Truth.assertThat;
 
@@ -50,7 +48,6 @@
 import android.database.sqlite.SQLiteDatabase;
 import android.os.UserHandle;
 import android.os.UserManager;
-import android.util.LongSparseArray;
 
 import androidx.test.ext.junit.runners.AndroidJUnit4;
 import androidx.test.filters.SmallTest;
@@ -60,9 +57,17 @@
 import com.android.launcher3.LauncherSettings;
 import com.android.launcher3.LauncherSettings.Favorites;
 import com.android.launcher3.backuprestore.LauncherRestoreEventLogger;
+import com.android.launcher3.dagger.LauncherAppComponent;
+import com.android.launcher3.dagger.LauncherAppSingleton;
 import com.android.launcher3.model.ModelDbController;
+import com.android.launcher3.pm.UserCache;
+import com.android.launcher3.util.AllModulesForTest;
 import com.android.launcher3.util.IntArray;
 import com.android.launcher3.util.LauncherModelHelper;
+import com.android.launcher3.util.LauncherModelHelper.SandboxModelContext;
+
+import dagger.BindsInstance;
+import dagger.Component;
 
 import org.junit.After;
 import org.junit.Before;
@@ -85,7 +90,9 @@
     private final UserHandle mWorkUser = UserHandle.getUserHandleForUid(PER_USER_RANGE);
 
     private LauncherModelHelper mModelHelper;
-    private Context mContext;
+    private SandboxModelContext mContext;
+    private UserCache mUserCacheSpy;
+
     private RestoreDbTask mTask;
     private ModelDbController mMockController;
     private SQLiteDatabase mMockDb;
@@ -94,10 +101,17 @@
     private LauncherRestoreEventLogger mMockRestoreEventLogger;
     private SQLiteDatabase mDb;
 
+    private AppWidgetHost mWidgetHost;
+
     @Before
     public void setup() {
         mModelHelper = new LauncherModelHelper();
         mContext = mModelHelper.sandboxContext;
+        mUserCacheSpy = spy(UserCache.getInstance(getInstrumentation().getTargetContext()));
+
+        mContext.initDaggerComponent(
+                DaggerRestoreDbTaskTest_TestComponent.builder().bindUserCache(mUserCacheSpy));
+
         mTask = new RestoreDbTask();
         mMockController = Mockito.mock(ModelDbController.class);
         mMockDb = mock(SQLiteDatabase.class);
@@ -106,24 +120,34 @@
         mMockRestoreEventLogger = mock(LauncherRestoreEventLogger.class);
     }
 
+    private synchronized AppWidgetHost getWidgetHostLazy() {
+        if (mWidgetHost == null) {
+            mWidgetHost = new AppWidgetHost(mContext, 1012);
+        }
+        return mWidgetHost;
+    }
+
     @After
     public void teardown() {
         if (mDb != null) {
             mDb.close();
         }
+        if (mWidgetHost != null) {
+            mWidgetHost.deleteHost();
+        }
         mModelHelper.destroy();
         LauncherPrefs.get(mContext).removeSync(RESTORE_DEVICE);
     }
 
     @Test
     public void testGetProfileId() throws Exception {
-        mDb = new MyModelDbController(23).getDb();
+        mDb = getModelDbController(23).getDb();
         assertEquals(23, new RestoreDbTask().getDefaultProfileId(mDb));
     }
 
     @Test
     public void testMigrateProfileId() throws Exception {
-        mDb = new MyModelDbController(42).getDb();
+        mDb = getModelDbController(42).getDb();
         // Add some mock data
         for (int i = 0; i < 5; i++) {
             ContentValues values = new ContentValues();
@@ -143,7 +167,7 @@
 
     @Test
     public void testChangeDefaultColumn() throws Exception {
-        mDb = new MyModelDbController(42).getDb();
+        mDb = getModelDbController(42).getDb();
         // Add some mock data
         for (int i = 0; i < 5; i++) {
             ContentValues values = new ContentValues();
@@ -173,12 +197,12 @@
         long workProfileId = myProfileId + 2;
         long workProfileId_old = myProfileId + 3;
 
-        MyModelDbController controller = new MyModelDbController(myProfileId);
+        ModelDbController controller = getModelDbController(myProfileId);
         mDb = controller.getDb();
         BackupManager bm = spy(new BackupManager(mContext));
         doReturn(myUserHandle()).when(bm).getUserForAncestralSerialNumber(eq(myProfileId_old));
         doReturn(mWorkUser).when(bm).getUserForAncestralSerialNumber(eq(workProfileId_old));
-        controller.users.put(workProfileId, mWorkUser);
+        doReturn(workProfileId).when(mUserCacheSpy).getSerialNumberForUser(mWorkUser);
 
         addIconsBulk(controller, 10, 1, myProfileId_old);
         addIconsBulk(controller, 6, 2, workProfileId_old);
@@ -202,7 +226,7 @@
         long myProfileId_old = myProfileId + 1;
         long workProfileId_old = myProfileId + 3;
 
-        MyModelDbController controller = new MyModelDbController(myProfileId);
+        ModelDbController controller = getModelDbController(myProfileId);
         mDb = controller.getDb();
         BackupManager bm = spy(new BackupManager(mContext));
         doReturn(myUserHandle()).when(bm).getUserForAncestralSerialNumber(eq(myProfileId_old));
@@ -226,7 +250,8 @@
     @Test
     public void givenLauncherPrefsHasNoIds_whenRestoreAppWidgetIdsIfExists_thenIdsAreRemoved() {
         // When
-        mTask.restoreAppWidgetIdsIfExists(mContext, mMockController, mMockRestoreEventLogger);
+        mTask.restoreAppWidgetIdsIfExists(mContext, mMockController, mMockRestoreEventLogger,
+                this::getWidgetHostLazy);
         // Then
         assertThat(mPrefs.has(OLD_APP_WIDGET_IDS, APP_WIDGET_IDS)).isFalse();
     }
@@ -234,7 +259,7 @@
     @Test
     public void givenNoPendingRestore_WhenRestoreAppWidgetIds_ThenRemoveNewWidgetIds() {
         // Given
-        AppWidgetHost expectedHost = new AppWidgetHost(mContext, APPWIDGET_HOST_ID);
+        AppWidgetHost expectedHost = getWidgetHostLazy();
         int[] expectedOldIds = generateOldWidgetIds(expectedHost);
         int[] expectedNewIds = generateNewWidgetIds(expectedHost, expectedOldIds);
         when(mMockController.getDb()).thenReturn(mMockDb);
@@ -242,7 +267,8 @@
 
         // When
         setRestoredAppWidgetIds(mContext, expectedOldIds, expectedNewIds);
-        mTask.restoreAppWidgetIdsIfExists(mContext, mMockController, mMockRestoreEventLogger);
+        mTask.restoreAppWidgetIdsIfExists(mContext, mMockController, mMockRestoreEventLogger,
+                this::getWidgetHostLazy);
 
         // Then
         assertThat(expectedHost.getAppWidgetIds()).isEqualTo(expectedOldIds);
@@ -254,7 +280,7 @@
     @Test
     public void givenRestoreWithNonExistingWidgets_WhenRestoreAppWidgetIds_ThenRemoveNewIds() {
         // Given
-        AppWidgetHost expectedHost = new AppWidgetHost(mContext, APPWIDGET_HOST_ID);
+        AppWidgetHost expectedHost = getWidgetHostLazy();
         int[] expectedOldIds = generateOldWidgetIds(expectedHost);
         int[] expectedNewIds = generateNewWidgetIds(expectedHost, expectedOldIds);
         when(mMockController.getDb()).thenReturn(mMockDb);
@@ -265,18 +291,19 @@
 
         // When
         setRestoredAppWidgetIds(mContext, expectedOldIds, expectedNewIds);
-        mTask.restoreAppWidgetIdsIfExists(mContext, mMockController, mMockRestoreEventLogger);
+        mTask.restoreAppWidgetIdsIfExists(mContext, mMockController, mMockRestoreEventLogger,
+                this::getWidgetHostLazy);
 
         // Then
         assertThat(expectedHost.getAppWidgetIds()).isEqualTo(expectedOldIds);
         assertThat(mPrefs.has(OLD_APP_WIDGET_IDS, APP_WIDGET_IDS)).isFalse();
-        verify(mMockController, times(expectedOldIds.length)).update(any(), any(), any(), any());
+        verify(mMockController, times(expectedOldIds.length)).update(any(), any(), any());
     }
 
     @Test
     public void givenRestore_WhenRestoreAppWidgetIds_ThenAddNewIds() {
         // Given
-        AppWidgetHost expectedHost = new AppWidgetHost(mContext, APPWIDGET_HOST_ID);
+        AppWidgetHost expectedHost = getWidgetHostLazy();
         int[] expectedOldIds = generateOldWidgetIds(expectedHost);
         int[] expectedNewIds = generateNewWidgetIds(expectedHost, expectedOldIds);
         int[] allExpectedIds = IntStream.concat(
@@ -294,15 +321,16 @@
 
         // When
         setRestoredAppWidgetIds(mContext, expectedOldIds, expectedNewIds);
-        mTask.restoreAppWidgetIdsIfExists(mContext, mMockController, mMockRestoreEventLogger);
+        mTask.restoreAppWidgetIdsIfExists(mContext, mMockController, mMockRestoreEventLogger,
+                this::getWidgetHostLazy);
 
         // Then
         assertThat(expectedHost.getAppWidgetIds()).isEqualTo(allExpectedIds);
         assertThat(mPrefs.has(OLD_APP_WIDGET_IDS, APP_WIDGET_IDS)).isFalse();
-        verify(mMockController, times(expectedOldIds.length)).update(any(), any(), any(), any());
+        verify(mMockController, times(expectedOldIds.length)).update(any(), any(), any());
     }
 
-    private void addIconsBulk(MyModelDbController controller,
+    private void addIconsBulk(ModelDbController controller,
             int count, int screen, long profileId) {
         int columns = LauncherAppState.getIDP(mContext).numColumns;
         String packageName = getInstrumentation().getContext().getPackageName();
@@ -320,7 +348,7 @@
             values.put(LauncherSettings.Favorites.INTENT,
                     new Intent(Intent.ACTION_MAIN).setPackage(packageName).toUri(0));
 
-            controller.insert(TABLE_NAME, values);
+            controller.insert(values);
         }
     }
 
@@ -346,7 +374,7 @@
     }
 
     private void runRemoveScreenIdGapsTest(int[] screenIds, int[] expectedScreenIds) {
-        mDb = new MyModelDbController(42).getDb();
+        mDb = getModelDbController(42).getDb();
         // Add some mock data
         for (int i = 0; i < screenIds.length; i++) {
             ContentValues values = new ContentValues();
@@ -397,25 +425,29 @@
                 .map(id -> host.allocateAppWidgetId()).toArray();
     }
 
-    private class MyModelDbController extends ModelDbController {
-
-        public final LongSparseArray<UserHandle> users = new LongSparseArray<>();
-
-        MyModelDbController(long profileId) {
-            super(mContext);
-            users.put(profileId, myUserHandle());
-        }
-
-        @Override
-        public long getSerialNumberForUser(UserHandle user) {
-            int index = users.indexOfValue(user);
-            return index >= 0 ? users.keyAt(index) : -1;
-        }
-    }
-
     private void setRestoredAppWidgetIds(Context context, int[] oldIds, int[] newIds) {
         LauncherPrefs.get(context).putSync(
                 OLD_APP_WIDGET_IDS.to(IntArray.wrap(oldIds).toConcatString()),
                 APP_WIDGET_IDS.to(IntArray.wrap(newIds).toConcatString()));
     }
+
+    private ModelDbController getModelDbController(long profileId) {
+        doReturn(profileId).when(mUserCacheSpy).getSerialNumberForUser(myUserHandle());
+        return ((TestComponent) mContext.getAppComponent()).getDbController();
+    }
+
+    @LauncherAppSingleton
+    @Component(modules = AllModulesForTest.class)
+    public interface TestComponent extends LauncherAppComponent {
+
+        ModelDbController getDbController();
+
+        @Component.Builder
+        interface Builder extends LauncherAppComponent.Builder {
+
+            @BindsInstance Builder bindUserCache(UserCache userCache);
+
+            TestComponent build();
+        }
+    }
 }
diff --git a/tests/multivalentTests/src/com/android/launcher3/util/DaggerGraphs.kt b/tests/multivalentTests/src/com/android/launcher3/util/DaggerGraphs.kt
index b66a9d3..a76ccf0 100644
--- a/tests/multivalentTests/src/com/android/launcher3/util/DaggerGraphs.kt
+++ b/tests/multivalentTests/src/com/android/launcher3/util/DaggerGraphs.kt
@@ -21,6 +21,7 @@
 import com.android.launcher3.dagger.ApiWrapperModule
 import com.android.launcher3.dagger.AppModule
 import com.android.launcher3.dagger.StaticObjectModule
+import com.android.launcher3.dagger.WidgetModule
 import com.android.launcher3.dagger.WindowManagerProxyModule
 import dagger.Binds
 import dagger.Module
@@ -39,15 +40,27 @@
             ApiWrapperModule::class,
             WindowManagerProxyModule::class,
             StaticObjectModule::class,
+            WidgetModule::class,
             AppModule::class,
         ]
 )
 class AllModulesForTest
 
 /** All modules except the WMProxy */
-@Module(includes = [ApiWrapperModule::class, StaticObjectModule::class, AppModule::class])
+@Module(
+    includes =
+        [ApiWrapperModule::class, StaticObjectModule::class, AppModule::class, WidgetModule::class]
+)
 class AllModulesMinusWMProxy
 
 /** All modules except the ApiWrapper */
-@Module(includes = [WindowManagerProxyModule::class, StaticObjectModule::class, AppModule::class])
+@Module(
+    includes =
+        [
+            WindowManagerProxyModule::class,
+            StaticObjectModule::class,
+            AppModule::class,
+            WidgetModule::class,
+        ]
+)
 class AllModulesMinusApiWrapper
diff --git a/tests/multivalentTests/src/com/android/launcher3/util/ModelTestExtensions.kt b/tests/multivalentTests/src/com/android/launcher3/util/ModelTestExtensions.kt
index ceefb0d..524acff 100644
--- a/tests/multivalentTests/src/com/android/launcher3/util/ModelTestExtensions.kt
+++ b/tests/multivalentTests/src/com/android/launcher3/util/ModelTestExtensions.kt
@@ -1,10 +1,11 @@
 package com.android.launcher3.util
 
 import android.content.ContentValues
+import android.database.sqlite.SQLiteDatabase
 import android.os.Process
+import androidx.test.platform.app.InstrumentationRegistry
 import com.android.launcher3.Flags
 import com.android.launcher3.LauncherModel
-import com.android.launcher3.LauncherSettings.Favorites
 import com.android.launcher3.LauncherSettings.Favorites.APPWIDGET_ID
 import com.android.launcher3.LauncherSettings.Favorites.APPWIDGET_PROVIDER
 import com.android.launcher3.LauncherSettings.Favorites.APPWIDGET_SOURCE
@@ -24,6 +25,8 @@
 import com.android.launcher3.LauncherSettings.Favorites._ID
 import com.android.launcher3.model.BgDataModel
 import com.android.launcher3.model.ModelDbController
+import java.io.BufferedReader
+import java.io.InputStreamReader
 
 object ModelTestExtensions {
     /** Clears and reloads Launcher db to cleanup the workspace */
@@ -68,7 +71,6 @@
         spanY: Int = 1,
         id: Int = 0,
         profileId: Int = Process.myUserHandle().identifier,
-        tableName: String = Favorites.TABLE_NAME,
         appWidgetId: Int = -1,
         appWidgetSource: Int = -1,
         appWidgetProvider: String? = null,
@@ -97,9 +99,21 @@
                         values[APPWIDGET_PROVIDER] = appWidgetProvider
                     }
                 // Migrate any previous data so that the DB state is correct
-                controller.insert(tableName, values)
+                controller.insert(values)
                 transaction.commit()
             }
         }
     }
+
+    /** Creates an in-memory sqlite DB and initializes with the data in [insertFile] */
+    fun createInMemoryDb(insertFile: String): SQLiteDatabase =
+        SQLiteDatabase.createInMemory(SQLiteDatabase.OpenParams.Builder().build()).also { db ->
+            BufferedReader(
+                    InputStreamReader(
+                        InstrumentationRegistry.getInstrumentation().context.assets.open(insertFile)
+                    )
+                )
+                .lines()
+                .forEach { sqlStatement -> db.execSQL(sqlStatement) }
+        }
 }
diff --git a/tests/multivalentTests/src/com/android/launcher3/util/SimpleBroadcastReceiverTest.kt b/tests/multivalentTests/src/com/android/launcher3/util/SimpleBroadcastReceiverTest.kt
index 17933f2..97651d3 100644
--- a/tests/multivalentTests/src/com/android/launcher3/util/SimpleBroadcastReceiverTest.kt
+++ b/tests/multivalentTests/src/com/android/launcher3/util/SimpleBroadcastReceiverTest.kt
@@ -127,6 +127,29 @@
     }
 
     @Test
+    fun sync_register_withCompletionRunnable_and_permission_and_flag() {
+        underTest =
+            SimpleBroadcastReceiver(context, Handler(Looper.getMainLooper()), intentConsumer)
+
+        underTest.register(completionRunnable, "permission", 1, "test_action_1", "test_action_2")
+        getInstrumentation().waitForIdleSync()
+
+        verify(context)
+            .registerReceiver(
+                same(underTest),
+                intentFilterCaptor.capture(),
+                eq("permission"),
+                eq(null),
+                eq(1),
+            )
+        verify(completionRunnable).run()
+        val intentFilter = intentFilterCaptor.value
+        assertThat(intentFilter.countActions()).isEqualTo(2)
+        assertThat(intentFilter.getAction(0)).isEqualTo("test_action_1")
+        assertThat(intentFilter.getAction(1)).isEqualTo("test_action_2")
+    }
+
+    @Test
     fun async_unregister() {
         underTest.unregisterReceiverSafely()
 
diff --git a/tests/multivalentTests/src/com/android/launcher3/widget/LauncherAppWidgetHostTest.kt b/tests/multivalentTests/src/com/android/launcher3/widget/LauncherAppWidgetHostTest.kt
index 79b493a..d5d1f4a 100644
--- a/tests/multivalentTests/src/com/android/launcher3/widget/LauncherAppWidgetHostTest.kt
+++ b/tests/multivalentTests/src/com/android/launcher3/widget/LauncherAppWidgetHostTest.kt
@@ -21,32 +21,22 @@
 import androidx.test.platform.app.InstrumentationRegistry.getInstrumentation
 import com.android.launcher3.util.ActivityContextWrapper
 import com.android.launcher3.util.Executors
+import com.android.launcher3.util.TestUtil
 import java.util.function.IntConsumer
 import org.junit.Assert.assertNotSame
 import org.junit.Assert.assertNull
 import org.junit.Assert.assertSame
-import org.junit.Before
 import org.junit.Test
 import org.junit.runner.RunWith
-import org.mockito.Mock
 import org.mockito.Mockito.mock
 import org.mockito.Mockito.verify
-import org.mockito.MockitoAnnotations
 
 @SmallTest
 @RunWith(AndroidJUnit4::class)
 class LauncherAppWidgetHostTest {
 
-    @Mock private lateinit var onAppWidgetRemovedCallback: IntConsumer
-
     private val context = ActivityContextWrapper(getInstrumentation().targetContext)
-    private lateinit var underTest: LauncherAppWidgetHost
-
-    @Before
-    fun setUp() {
-        MockitoAnnotations.initMocks(this)
-        underTest = LauncherAppWidgetHost(context, onAppWidgetRemovedCallback, emptyList())
-    }
+    private var underTest = LauncherAppWidgetHost(context, HOST_ID)
 
     @Test
     fun `Host set view to recycle`() {
@@ -74,15 +64,20 @@
 
     @Test
     fun `Runnable called when app widget removed`() {
+        val holder = LauncherWidgetHolder(context, underTest)
+        holder.setAppWidgetRemovedCallback(mock(IntConsumer::class.java))
+        TestUtil.runOnExecutorSync(Executors.MAIN_EXECUTOR) {}
+
         underTest.onAppWidgetRemoved(WIDGET_ID)
 
         Executors.MODEL_EXECUTOR.submit {}.get()
         getInstrumentation().waitForIdleSync()
 
-        verify(onAppWidgetRemovedCallback).accept(WIDGET_ID)
+        verify(holder.mAppWidgetRemovedCallback!!).accept(WIDGET_ID)
     }
 
     companion object {
+        const val HOST_ID = 2233
         const val WIDGET_ID = 10001
     }
 }
diff --git a/tests/multivalentTests/src/com/android/launcher3/widget/LauncherWidgetHolderTest.kt b/tests/multivalentTests/src/com/android/launcher3/widget/LauncherWidgetHolderTest.kt
index 1a659e2..44f29d6 100644
--- a/tests/multivalentTests/src/com/android/launcher3/widget/LauncherWidgetHolderTest.kt
+++ b/tests/multivalentTests/src/com/android/launcher3/widget/LauncherWidgetHolderTest.kt
@@ -47,7 +47,7 @@
     fun setUp() {
         assertTrue(WIDGETS_ENABLED)
         widgetHolder =
-            LauncherWidgetHolder(ActivityContextWrapper(getInstrumentation().targetContext)) {}
+            LauncherWidgetHolder(ActivityContextWrapper(getInstrumentation().targetContext))
     }
 
     @After
@@ -62,7 +62,7 @@
         widgetHolder.setListeningFlag(false)
         assertFalse(widgetHolder.isListening)
         widgetHolder.startListening()
-        widgetHolder.widgetHolderExecutor.submit {}.get()
+        ListenableAppWidgetHost.widgetHolderExecutor.submit {}.get()
         getInstrumentation().waitForIdleSync()
         assertTrue(widgetHolder.isListening)
         verify(testView, times(1)).reInflate()
@@ -73,10 +73,10 @@
     fun holder_start_listening_after_activity_start() {
         widgetHolder.setShouldListenFlag(FLAG_STATE_IS_NORMAL or FLAG_ACTIVITY_RESUMED, true)
         widgetHolder.setActivityStarted(false)
-        widgetHolder.widgetHolderExecutor.submit {}.get()
+        ListenableAppWidgetHost.widgetHolderExecutor.submit {}.get()
         assertFalse(widgetHolder.shouldListen(widgetHolder.mFlags.get()))
         widgetHolder.setActivityStarted(true)
-        widgetHolder.widgetHolderExecutor.submit {}.get()
+        ListenableAppWidgetHost.widgetHolderExecutor.submit {}.get()
         assertTrue(widgetHolder.shouldListen(widgetHolder.mFlags.get()))
     }
 
@@ -84,10 +84,10 @@
     fun holder_start_listening_after_activity_resume() {
         widgetHolder.setShouldListenFlag(FLAG_STATE_IS_NORMAL or FLAG_ACTIVITY_STARTED, true)
         widgetHolder.setActivityResumed(false)
-        widgetHolder.widgetHolderExecutor.submit {}.get()
+        ListenableAppWidgetHost.widgetHolderExecutor.submit {}.get()
         assertFalse(widgetHolder.shouldListen(widgetHolder.mFlags.get()))
         widgetHolder.setActivityResumed(true)
-        widgetHolder.widgetHolderExecutor.submit {}.get()
+        ListenableAppWidgetHost.widgetHolderExecutor.submit {}.get()
         assertTrue(widgetHolder.shouldListen(widgetHolder.mFlags.get()))
     }
 
@@ -95,10 +95,10 @@
     fun holder_start_listening_after_state_normal() {
         widgetHolder.setShouldListenFlag(FLAG_ACTIVITY_RESUMED or FLAG_ACTIVITY_STARTED, true)
         widgetHolder.setStateIsNormal(false)
-        widgetHolder.widgetHolderExecutor.submit {}.get()
+        ListenableAppWidgetHost.widgetHolderExecutor.submit {}.get()
         assertFalse(widgetHolder.shouldListen(widgetHolder.mFlags.get()))
         widgetHolder.setStateIsNormal(true)
-        widgetHolder.widgetHolderExecutor.submit {}.get()
+        ListenableAppWidgetHost.widgetHolderExecutor.submit {}.get()
         assertTrue(widgetHolder.shouldListen(widgetHolder.mFlags.get()))
     }
 
@@ -117,7 +117,7 @@
 
     @Test
     fun holder_add_provider_change_listener() {
-        val listener = LauncherWidgetHolder.ProviderChangedListener {}
+        val listener = ListenableAppWidgetHost.ProviderChangedListener {}
         widgetHolder.addProviderChangeListener(listener)
         getInstrumentation().waitForIdleSync()
         assertEquals(1, widgetHolder.mProviderChangedListeners.size)
@@ -127,7 +127,7 @@
 
     @Test
     fun holder_remove_provider_change_listener() {
-        val listener = LauncherWidgetHolder.ProviderChangedListener {}
+        val listener = ListenableAppWidgetHost.ProviderChangedListener {}
         widgetHolder.addProviderChangeListener(listener)
         widgetHolder.removeProviderChangeListener(listener)
         getInstrumentation().waitForIdleSync()
@@ -139,7 +139,7 @@
         widgetHolder.setListeningFlag(true)
         assertTrue(widgetHolder.isListening)
         widgetHolder.stopListening()
-        widgetHolder.widgetHolderExecutor.submit {}.get()
+        ListenableAppWidgetHost.widgetHolderExecutor.submit {}.get()
         assertFalse(widgetHolder.isListening)
     }
 
diff --git a/tests/src/com/android/launcher3/backuprestore/BackupAndRestoreDBSelectionTest.kt b/tests/src/com/android/launcher3/backuprestore/BackupAndRestoreDBSelectionTest.kt
index 38fad6b..34d9d40 100644
--- a/tests/src/com/android/launcher3/backuprestore/BackupAndRestoreDBSelectionTest.kt
+++ b/tests/src/com/android/launcher3/backuprestore/BackupAndRestoreDBSelectionTest.kt
@@ -23,8 +23,8 @@
 import androidx.test.filters.MediumTest
 import androidx.test.platform.app.InstrumentationRegistry.getInstrumentation
 import com.android.launcher3.Flags
+import com.android.launcher3.LauncherAppState
 import com.android.launcher3.LauncherPrefs
-import com.android.launcher3.model.ModelDbController
 import com.android.launcher3.model.ModelDelegate
 import com.android.launcher3.provider.RestoreDbTask
 import com.android.launcher3.util.Executors.MODEL_EXECUTOR
@@ -45,11 +45,8 @@
 @MediumTest
 class BackupAndRestoreDBSelectionTest {
 
-    @JvmField @Rule var backAndRestoreRule = BackAndRestoreRule()
-
-    @JvmField
-    @Rule
-    val setFlagsRule = SetFlagsRule(SetFlagsRule.DefaultInitValueType.DEVICE_DEFAULT)
+    @get:Rule var backAndRestoreRule = BackAndRestoreRule()
+    @get:Rule val setFlagsRule = SetFlagsRule()
 
     val modelDelegate = mock<ModelDelegate>()
 
@@ -70,7 +67,8 @@
 
     @Test
     fun oldDatabasesNotPresentAfterRestore() {
-        val dbController = ModelDbController(getInstrumentation().targetContext)
+        val dbController =
+            LauncherAppState.getInstance(getInstrumentation().targetContext).model.modelDbController
         if (Flags.gridMigrationRefactor()) {
             dbController.attemptMigrateDb(null, modelDelegate)
         } else {
diff --git a/tests/src/com/android/launcher3/model/LoaderTaskTest.kt b/tests/src/com/android/launcher3/model/LoaderTaskTest.kt
index 246219f..560d306 100644
--- a/tests/src/com/android/launcher3/model/LoaderTaskTest.kt
+++ b/tests/src/com/android/launcher3/model/LoaderTaskTest.kt
@@ -5,6 +5,7 @@
 import android.content.Intent
 import android.content.pm.ApplicationInfo
 import android.content.pm.LauncherActivityInfo
+import android.database.sqlite.SQLiteDatabase
 import android.os.Process
 import android.os.UserHandle
 import android.platform.test.annotations.DisableFlags
@@ -16,7 +17,6 @@
 import com.android.dx.mockito.inline.extended.ExtendedMockito
 import com.android.dx.mockito.inline.extended.ExtendedMockito.spyOn
 import com.android.launcher3.Flags
-import com.android.launcher3.LauncherAppState
 import com.android.launcher3.LauncherModel
 import com.android.launcher3.LauncherModel.LoaderTransaction
 import com.android.launcher3.LauncherPrefs
@@ -26,11 +26,13 @@
 import com.android.launcher3.LauncherSettings.Favorites.CONTAINER_HOTSEAT
 import com.android.launcher3.LauncherSettings.Favorites.ITEM_TYPE_APP_PAIR
 import com.android.launcher3.LauncherSettings.Favorites.ITEM_TYPE_FOLDER
+import com.android.launcher3.LauncherSettings.Favorites.TABLE_NAME
 import com.android.launcher3.dagger.LauncherAppComponent
 import com.android.launcher3.dagger.LauncherAppSingleton
 import com.android.launcher3.icons.IconCache
 import com.android.launcher3.icons.cache.CachingLogic
 import com.android.launcher3.icons.cache.IconCacheUpdateHandler
+import com.android.launcher3.model.LoaderTask.LoaderTaskFactory
 import com.android.launcher3.model.data.AppInfo
 import com.android.launcher3.model.data.IconRequestInfo
 import com.android.launcher3.model.data.WorkspaceItemInfo
@@ -41,9 +43,9 @@
 import com.android.launcher3.util.Executors.MODEL_EXECUTOR
 import com.android.launcher3.util.LauncherModelHelper.SandboxModelContext
 import com.android.launcher3.util.LooperIdleLock
+import com.android.launcher3.util.ModelTestExtensions
 import com.android.launcher3.util.TestUtil
 import com.android.launcher3.util.UserIconInfo
-import com.google.common.truth.Truth
 import com.google.common.truth.Truth.assertThat
 import dagger.BindsInstance
 import dagger.Component
@@ -57,7 +59,6 @@
 import org.mockito.ArgumentCaptor
 import org.mockito.Mock
 import org.mockito.Mockito
-import org.mockito.Mockito.mock
 import org.mockito.Mockito.times
 import org.mockito.Mockito.`when`
 import org.mockito.MockitoAnnotations
@@ -65,6 +66,7 @@
 import org.mockito.Spy
 import org.mockito.kotlin.any
 import org.mockito.kotlin.anyOrNull
+import org.mockito.kotlin.doAnswer
 import org.mockito.kotlin.doReturn
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.verify
@@ -93,26 +95,33 @@
 
     @Mock private lateinit var bgAllAppsList: AllAppsList
     @Mock private lateinit var modelDelegate: ModelDelegate
-    @Mock private lateinit var launcherBinder: BaseLauncherBinder
-    private lateinit var launcherModel: LauncherModel
-    @Mock private lateinit var transaction: LoaderTransaction
+    @Mock private lateinit var launcherModel: LauncherModel
     @Mock private lateinit var iconCache: IconCache
+    @Mock private lateinit var userCache: UserCache
+    @Mock private lateinit var modelDbController: ModelDbController
+
+    @Mock private lateinit var launcherBinder: BaseLauncherBinder
+    @Mock private lateinit var transaction: LoaderTransaction
     @Mock private lateinit var idleLock: LooperIdleLock
     @Mock private lateinit var iconCacheUpdateHandler: IconCacheUpdateHandler
-    @Mock private lateinit var userCache: UserCache
 
-    @Spy private var userManagerState: UserManagerState? = UserManagerState()
+    @Spy private var userManagerState: UserManagerState = UserManagerState()
 
     @get:Rule val setFlagsRule = SetFlagsRule()
 
-    private val app: LauncherAppState
-        get() = context.appComponent.launcherAppState
+    private val testComponent: TestComponent
+        get() = context.appComponent as TestComponent
+
+    private val bgDataModel: BgDataModel
+        get() = testComponent.getDataModel()
+
+    private val inMemoryDb: SQLiteDatabase by lazy {
+        ModelTestExtensions.createInMemoryDb(INSERTION_STATEMENT_FILE)
+    }
 
     @Before
     fun setup() {
         MockitoAnnotations.initMocks(this)
-        setFlagsRule.enableFlags(Flags.FLAG_ENABLE_TIERED_WIDGETS_BY_DEFAULT_IN_PICKER)
-        launcherModel = mock(LauncherModel::class.java)
         mockitoSession =
             ExtendedMockito.mockitoSession()
                 .strictness(Strictness.LENIENT)
@@ -123,16 +132,34 @@
             .getAppWidgetInfo(any())
 
         `when`(launcherModel.beginLoader(any())).thenReturn(transaction)
-        `when`(launcherModel.modelDbController)
-            .thenReturn(FactitiousDbController(context, INSERTION_STATEMENT_FILE))
+
+        `when`(launcherModel.modelDbController).thenReturn(modelDbController)
+        doAnswer {}.whenever(modelDbController).loadDefaultFavoritesIfNecessary()
+        doAnswer { i ->
+                inMemoryDb.query(
+                    TABLE_NAME,
+                    i.getArgument(0),
+                    i.getArgument(1),
+                    i.getArgument(2),
+                    null,
+                    null,
+                    i.getArgument(3),
+                )
+            }
+            .whenever(modelDbController)
+            .query(anyOrNull(), anyOrNull(), anyOrNull(), anyOrNull())
+
+        `when`(launcherModel.modelDelegate).thenReturn(modelDelegate)
         `when`(launcherBinder.newIdleLock(any())).thenReturn(idleLock)
         `when`(idleLock.awaitLocked(1000)).thenReturn(false)
         `when`(iconCache.getUpdateHandler()).thenReturn(iconCacheUpdateHandler)
+
         context.initDaggerComponent(
             DaggerLoaderTaskTest_TestComponent.builder()
                 .bindUserCache(userCache)
                 .bindIconCache(iconCache)
                 .bindLauncherModel(launcherModel)
+                .bindAllAppsList(bgAllAppsList)
         )
         context.appComponent.idp.apply {
             numRows = 5
@@ -146,20 +173,23 @@
     fun tearDown() {
         LauncherPrefs.get(context).removeSync(RESTORE_DEVICE)
         LauncherPrefs.get(context).putSync(IS_FIRST_LOAD_AFTER_RESTORE.to(false))
+        inMemoryDb.close()
         context.onDestroy()
         mockitoSession.finishMocking()
     }
 
     @Test
     fun loadsDataProperly() =
-        with(BgDataModel()) {
+        with(bgDataModel) {
             val MAIN_HANDLE = Process.myUserHandle()
             val mockUserHandles = arrayListOf<UserHandle>(MAIN_HANDLE)
             `when`(userCache.userProfiles).thenReturn(mockUserHandles)
             `when`(userCache.getUserInfo(MAIN_HANDLE)).thenReturn(UserIconInfo(MAIN_HANDLE, 1))
-            LoaderTask(app, bgAllAppsList, this, modelDelegate, launcherBinder)
+            testComponent
+                .getLoaderTaskFactory()
+                .newLoaderTask(launcherBinder, userManagerState)
                 .runSyncOnBackgroundThread()
-            Truth.assertThat(
+            assertThat(
                     itemsIdMap
                         .filter {
                             it.container == CONTAINER_DESKTOP || it.container == CONTAINER_HOTSEAT
@@ -167,9 +197,8 @@
                         .size
                 )
                 .isAtLeast(32)
-            Truth.assertThat(itemsIdMap.filter { ModelUtils.WIDGET_FILTER.test(it) }.size)
-                .isAtLeast(7)
-            Truth.assertThat(
+            assertThat(itemsIdMap.filter { ModelUtils.WIDGET_FILTER.test(it) }.size).isAtLeast(7)
+            assertThat(
                     itemsIdMap
                         .filter {
                             it.itemType == ITEM_TYPE_FOLDER || it.itemType == ITEM_TYPE_APP_PAIR
@@ -177,12 +206,14 @@
                         .size
                 )
                 .isAtLeast(8)
-            Truth.assertThat(itemsIdMap.size()).isAtLeast(40)
+            assertThat(itemsIdMap.size()).isAtLeast(40)
         }
 
     @Test
     fun bindsLoadedDataCorrectly() {
-        LoaderTask(app, bgAllAppsList, BgDataModel(), modelDelegate, launcherBinder)
+        testComponent
+            .getLoaderTaskFactory()
+            .newLoaderTask(launcherBinder, userManagerState)
             .runSyncOnBackgroundThread()
 
         verify(launcherBinder).bindWorkspace(true, false)
@@ -200,7 +231,7 @@
 
     @Test
     fun setsQuietModeFlagCorrectlyForWorkProfile() =
-        with(BgDataModel()) {
+        with(bgDataModel) {
             setFlagsRule.enableFlags(Flags.FLAG_ENABLE_PRIVATE_SPACE)
             val MAIN_HANDLE = Process.myUserHandle()
             val mockUserHandles = arrayListOf<UserHandle>(MAIN_HANDLE)
@@ -208,7 +239,9 @@
             `when`(userManagerState?.isUserQuiet(MAIN_HANDLE)).thenReturn(true)
             `when`(userCache.getUserInfo(MAIN_HANDLE)).thenReturn(UserIconInfo(MAIN_HANDLE, 1))
 
-            LoaderTask(app, bgAllAppsList, this, modelDelegate, launcherBinder, userManagerState)
+            testComponent
+                .getLoaderTaskFactory()
+                .newLoaderTask(launcherBinder, userManagerState)
                 .runSyncOnBackgroundThread()
 
             verify(bgAllAppsList)
@@ -221,7 +254,7 @@
 
     @Test
     fun setsQuietModeFlagCorrectlyForPrivateProfile() =
-        with(BgDataModel()) {
+        with(bgDataModel) {
             setFlagsRule.enableFlags(Flags.FLAG_ENABLE_PRIVATE_SPACE)
             val MAIN_HANDLE = Process.myUserHandle()
             val mockUserHandles = arrayListOf<UserHandle>(MAIN_HANDLE)
@@ -229,7 +262,9 @@
             `when`(userManagerState?.isUserQuiet(MAIN_HANDLE)).thenReturn(true)
             `when`(userCache.getUserInfo(MAIN_HANDLE)).thenReturn(UserIconInfo(MAIN_HANDLE, 3))
 
-            LoaderTask(app, bgAllAppsList, this, modelDelegate, launcherBinder, userManagerState)
+            testComponent
+                .getLoaderTaskFactory()
+                .newLoaderTask(launcherBinder, userManagerState)
                 .runSyncOnBackgroundThread()
 
             verify(bgAllAppsList)
@@ -268,7 +303,9 @@
         RestoreDbTask.setPending(spyContext)
 
         // When
-        LoaderTask(app, bgAllAppsList, BgDataModel(), modelDelegate, launcherBinder)
+        testComponent
+            .getLoaderTaskFactory()
+            .newLoaderTask(launcherBinder, userManagerState)
             .runSyncOnBackgroundThread()
 
         // Then
@@ -336,7 +373,9 @@
         Settings.Secure.putInt(spyContext.contentResolver, "launcher_broadcast_installed_apps", 0)
 
         // When
-        LoaderTask(app, bgAllAppsList, BgDataModel(), modelDelegate, launcherBinder)
+        testComponent
+            .getLoaderTaskFactory()
+            .newLoaderTask(launcherBinder, userManagerState)
             .runSyncOnBackgroundThread()
 
         // Then
@@ -375,7 +414,9 @@
         RestoreDbTask.setPending(spyContext)
 
         // When
-        LoaderTask(app, bgAllAppsList, BgDataModel(), modelDelegate, launcherBinder)
+        testComponent
+            .getLoaderTaskFactory()
+            .newLoaderTask(launcherBinder, userManagerState)
             .runSyncOnBackgroundThread()
 
         // Then
@@ -414,7 +455,9 @@
         RestoreDbTask.setPending(spyContext)
 
         // When
-        LoaderTask(app, bgAllAppsList, BgDataModel(), modelDelegate, launcherBinder)
+        testComponent
+            .getLoaderTaskFactory()
+            .newLoaderTask(launcherBinder, userManagerState)
             .runSyncOnBackgroundThread()
 
         // Then
@@ -444,7 +487,8 @@
             )
         val expectedAppInfo = AppInfo().apply { componentName = expectedComponent }
         // When
-        val loader = LoaderTask(app, bgAllAppsList, BgDataModel(), modelDelegate, launcherBinder)
+        val loader =
+            testComponent.getLoaderTaskFactory().newLoaderTask(launcherBinder, userManagerState)
         val actualIconRequest =
             loader.getAppInfoIconRequestInfo(expectedAppInfo, activityInfo, workspaceIconRequests)
         // Then
@@ -474,7 +518,8 @@
             )
         val expectedAppInfo = AppInfo().apply { componentName = expectedComponent }
         // When
-        val loader = LoaderTask(app, bgAllAppsList, BgDataModel(), modelDelegate, launcherBinder)
+        val loader =
+            testComponent.getLoaderTaskFactory().newLoaderTask(launcherBinder, userManagerState)
         val actualIconRequest =
             loader.getAppInfoIconRequestInfo(expectedAppInfo, activityInfo, workspaceIconRequests)
         // Then
@@ -505,7 +550,8 @@
         val expectedAppInfo =
             AppInfo().apply { componentName = ComponentName("differentPkg", "differentClass") }
         // When
-        val loader = LoaderTask(app, bgAllAppsList, BgDataModel(), modelDelegate, launcherBinder)
+        val loader =
+            testComponent.getLoaderTaskFactory().newLoaderTask(launcherBinder, userManagerState)
         val actualIconRequest =
             loader.getAppInfoIconRequestInfo(expectedAppInfo, activityInfo, workspaceIconRequests)
         // Then
@@ -532,7 +578,8 @@
             )
         val expectedAppInfo = AppInfo()
         // When
-        val loader = LoaderTask(app, bgAllAppsList, BgDataModel(), modelDelegate, launcherBinder)
+        val loader =
+            testComponent.getLoaderTaskFactory().newLoaderTask(launcherBinder, userManagerState)
         val actualIconRequest =
             loader.getAppInfoIconRequestInfo(expectedAppInfo, activityInfo, workspaceIconRequests)
         // Then
@@ -543,6 +590,11 @@
     @LauncherAppSingleton
     @Component(modules = [AllModulesForTest::class])
     interface TestComponent : LauncherAppComponent {
+
+        fun getLoaderTaskFactory(): LoaderTaskFactory
+
+        fun getDataModel(): BgDataModel
+
         @Component.Builder
         interface Builder : LauncherAppComponent.Builder {
             @BindsInstance fun bindUserCache(userCache: UserCache): Builder
@@ -551,6 +603,8 @@
 
             @BindsInstance fun bindIconCache(iconCache: IconCache): Builder
 
+            @BindsInstance fun bindAllAppsList(list: AllAppsList): Builder
+
             override fun build(): TestComponent
         }
     }
diff --git a/tests/src/com/android/launcher3/model/WorkspaceItemProcessorExtraTest.kt b/tests/src/com/android/launcher3/model/WorkspaceItemProcessorExtraTest.kt
index 8db049c..fd44023 100644
--- a/tests/src/com/android/launcher3/model/WorkspaceItemProcessorExtraTest.kt
+++ b/tests/src/com/android/launcher3/model/WorkspaceItemProcessorExtraTest.kt
@@ -30,12 +30,13 @@
 import androidx.test.core.app.ApplicationProvider
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import com.android.launcher3.Flags.FLAG_ENABLE_SUPPORT_FOR_ARCHIVING
-import com.android.launcher3.LauncherAppState
+import com.android.launcher3.InvariantDeviceProfile
 import com.android.launcher3.LauncherSettings.Favorites
 import com.android.launcher3.LauncherSettings.Favorites.CONTAINER_DESKTOP
 import com.android.launcher3.LauncherSettings.Favorites.ITEM_TYPE_APPLICATION
 import com.android.launcher3.LauncherSettings.Favorites.ITEM_TYPE_APPWIDGET
 import com.android.launcher3.icons.CacheableShortcutInfo
+import com.android.launcher3.icons.IconCache
 import com.android.launcher3.model.data.IconRequestInfo
 import com.android.launcher3.model.data.LauncherAppWidgetInfo
 import com.android.launcher3.model.data.LauncherAppWidgetInfo.FLAG_RESTORE_STARTED
@@ -52,11 +53,12 @@
 import org.junit.Before
 import org.junit.Test
 import org.junit.runner.RunWith
+import org.mockito.Answers
 import org.mockito.ArgumentCaptor
 import org.mockito.Mock
-import org.mockito.Mockito
 import org.mockito.Mockito.RETURNS_DEEP_STUBS
 import org.mockito.Mockito.verify
+import org.mockito.MockitoAnnotations
 import org.mockito.kotlin.any
 import org.mockito.kotlin.anyOrNull
 import org.mockito.kotlin.doAnswer
@@ -71,10 +73,10 @@
     @Mock private lateinit var mockWorkspaceInfo: WorkspaceItemInfo
     @Mock private lateinit var mockBgDataModel: BgDataModel
     @Mock private lateinit var mockContext: Context
-    @Mock private lateinit var mockAppState: LauncherAppState
+    @Mock private lateinit var mockIconCache: IconCache
     @Mock private lateinit var mockPmHelper: PackageManagerHelper
     @Mock private lateinit var mockLauncherApps: LauncherApps
-    @Mock private lateinit var mockCursor: LoaderCursor
+    @Mock(answer = Answers.RETURNS_DEEP_STUBS) private lateinit var mockCursor: LoaderCursor
     @Mock private lateinit var mockUserCache: UserCache
     @Mock private lateinit var mockUserManagerState: UserManagerState
     @Mock private lateinit var mockWidgetInflater: WidgetInflater
@@ -95,10 +97,9 @@
 
     @Before
     fun setup() {
+        MockitoAnnotations.initMocks(this)
+
         mUserHandle = UserHandle(0)
-        mockIconRequestInfo = mock<IconRequestInfo<WorkspaceItemInfo>>()
-        mockWorkspaceInfo = mock<WorkspaceItemInfo>()
-        mockBgDataModel = mock<BgDataModel>()
         mComponentName = ComponentName("package", "class")
         mUnlockedUsersArray = LongSparseArray<Boolean>(1).apply { put(101, true) }
         intent =
@@ -107,52 +108,36 @@
                 `package` = "pkg"
                 putExtra(ShortcutKey.EXTRA_SHORTCUT_ID, "")
             }
-        mockLauncherApps =
-            mock<LauncherApps>().apply {
-                whenever(isPackageEnabled("package", mUserHandle)).thenReturn(true)
-                whenever(isActivityEnabled(mComponentName, mUserHandle)).thenReturn(true)
-            }
-        mockContext =
-            mock<Context>().apply {
-                whenever(packageManager).thenReturn(mock())
-                whenever(packageManager.getUserBadgedLabel(any(), any())).thenReturn("")
-                whenever(applicationContext).thenReturn(ApplicationProvider.getApplicationContext())
-                whenever(getSystemService(LauncherApps::class.java)).thenReturn(mockLauncherApps)
-            }
-        mockAppState =
-            mock<LauncherAppState>().apply {
-                whenever(context).thenReturn(mockContext)
-                whenever(iconCache).thenReturn(mock())
-                whenever(iconCache.getShortcutIcon(any(), any(), any())).then {}
-            }
-        mockPmHelper =
-            mock<PackageManagerHelper>().apply {
-                whenever(getAppLaunchIntent(mComponentName.packageName, mUserHandle))
-                    .thenReturn(intent)
-            }
-        mockCursor =
-            Mockito.mock(LoaderCursor::class.java, RETURNS_DEEP_STUBS).apply {
-                user = mUserHandle
-                itemType = ITEM_TYPE_APPLICATION
-                id = 1
-                restoreFlag = 1
-                serialNumber = 101
-                whenever(parseIntent()).thenReturn(intent)
-                whenever(markRestored()).doAnswer { restoreFlag = 0 }
-                whenever(updater().put(Favorites.INTENT, intent.toUri(0)).commit()).thenReturn(1)
-                whenever(getAppShortcutInfo(any(), any(), any(), any()))
-                    .thenReturn(mockWorkspaceInfo)
-                whenever(createIconRequestInfo(any(), any())).thenReturn(mockIconRequestInfo)
-            }
-        mockUserCache =
-            mock<UserCache>().apply {
-                val userIconInfo =
-                    mock<UserIconInfo>().apply { whenever(isPrivate).thenReturn(false) }
-                whenever(getUserInfo(any())).thenReturn(userIconInfo)
-            }
+        mockLauncherApps.apply {
+            whenever(isPackageEnabled("package", mUserHandle)).thenReturn(true)
+            whenever(isActivityEnabled(mComponentName, mUserHandle)).thenReturn(true)
+        }
+        mockContext.apply {
+            whenever(packageManager).thenReturn(mock())
+            whenever(packageManager.getUserBadgedLabel(any(), any())).thenReturn("")
+            whenever(applicationContext).thenReturn(ApplicationProvider.getApplicationContext())
+            whenever(getSystemService(LauncherApps::class.java)).thenReturn(mockLauncherApps)
+        }
 
-        mockUserManagerState = mock<UserManagerState>()
-        mockWidgetInflater = mock<WidgetInflater>()
+        whenever(mockIconCache.getShortcutIcon(any(), any(), any())).then {}
+        whenever(mockPmHelper.getAppLaunchIntent(mComponentName.packageName, mUserHandle))
+            .thenReturn(intent)
+        mockCursor.apply {
+            user = mUserHandle
+            itemType = ITEM_TYPE_APPLICATION
+            id = 1
+            restoreFlag = 1
+            serialNumber = 101
+            whenever(parseIntent()).thenReturn(intent)
+            whenever(markRestored()).doAnswer { restoreFlag = 0 }
+            whenever(updater().put(Favorites.INTENT, intent.toUri(0)).commit()).thenReturn(1)
+            whenever(getAppShortcutInfo(any(), any(), any(), any())).thenReturn(mockWorkspaceInfo)
+            whenever(createIconRequestInfo(any(), any())).thenReturn(mockIconRequestInfo)
+        }
+
+        val mockUserInfo = mock<UserIconInfo>().apply { whenever(isPrivate).thenReturn(false) }
+        whenever(mockUserCache.getUserInfo(any())).thenReturn(mockUserInfo)
+
         mKeyToPinnedShortcutsMap = mutableMapOf()
         mInstallingPkgs = hashMapOf()
         mAllDeepShortcuts = mutableListOf()
@@ -283,7 +268,7 @@
         userManagerState: UserManagerState = mockUserManagerState,
         launcherApps: LauncherApps = mockLauncherApps,
         shortcutKeyToPinnedShortcuts: Map<ShortcutKey, ShortcutInfo> = mKeyToPinnedShortcutsMap,
-        app: LauncherAppState = mockAppState,
+        context: Context = mockContext,
         bgDataModel: BgDataModel = mockBgDataModel,
         widgetProvidersMap: MutableMap<ComponentKey, AppWidgetProviderInfo?> = mWidgetProvidersMap,
         widgetInflater: WidgetInflater = mockWidgetInflater,
@@ -297,11 +282,11 @@
     ) =
         WorkspaceItemProcessor(
             c = cursor,
+            context = context,
             memoryLogger = memoryLogger,
             userCache = userCache,
             userManagerState = userManagerState,
             launcherApps = launcherApps,
-            app = app,
             bgDataModel = bgDataModel,
             widgetProvidersMap = widgetProvidersMap,
             widgetInflater = widgetInflater,
@@ -313,5 +298,8 @@
             shortcutKeyToPinnedShortcuts = shortcutKeyToPinnedShortcuts,
             installingPkgs = installingPkgs,
             allDeepShortcuts = allDeepShortcuts,
+            idp = InvariantDeviceProfile.INSTANCE.get(context),
+            iconCache = mockIconCache,
+            isSafeMode = false,
         )
 }
diff --git a/tests/src/com/android/launcher3/ui/widget/BindWidgetTest.java b/tests/src/com/android/launcher3/ui/widget/BindWidgetTest.java
index 8846d65..67ee1ac 100644
--- a/tests/src/com/android/launcher3/ui/widget/BindWidgetTest.java
+++ b/tests/src/com/android/launcher3/ui/widget/BindWidgetTest.java
@@ -15,7 +15,6 @@
  */
 package com.android.launcher3.ui.widget;
 
-import static com.android.launcher3.LauncherSettings.Favorites.TABLE_NAME;
 import static com.android.launcher3.WorkspaceLayoutManager.FIRST_SCREEN_ID;
 import static com.android.launcher3.model.data.LauncherAppWidgetInfo.FLAG_ID_NOT_VALID;
 import static com.android.launcher3.model.data.LauncherAppWidgetInfo.FLAG_PROVIDER_NOT_READY;
@@ -318,7 +317,7 @@
         try {
             return MODEL_EXECUTOR.submit(() ->
                 mModel.getModelDbController().query(
-                                TABLE_NAME, null, itemIdMatch(0), null, null)).get();
+                        null, itemIdMatch(0), null, null)).get();
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
