diff --git a/Android.bp b/Android.bp
index 7bbbb10..64fc327 100644
--- a/Android.bp
+++ b/Android.bp
@@ -55,11 +55,15 @@
     static_libs: [
         "guava",
         "monet",
-	"renderscript_toolkit",
+	    "renderscript_toolkit",
         "wallpaper-common-deps",
         "SettingsLibSettingsTheme",
         "SystemUI-statsd",
         "styleprotoslite",
+        "androidx.lifecycle_lifecycle-runtime-ktx",
+        "androidx.lifecycle_lifecycle-viewmodel-ktx",
+        "androidx.recyclerview_recyclerview",
+        "SystemUICustomizationLib",
     ],
 
     jni_libs: [
diff --git a/AndroidManifest.xml b/AndroidManifest.xml
index ee96ae3..4282a08 100755
--- a/AndroidManifest.xml
+++ b/AndroidManifest.xml
@@ -8,8 +8,9 @@
     <uses-permission android:name="android.permission.CHANGE_OVERLAY_PACKAGES"/>
     <uses-permission android:name="android.permission.WRITE_SECURE_SETTINGS"/>
     <uses-permission android:name="android.permission.SET_WALLPAPER_COMPONENT" />
-
+    <uses-permission android:name="android.permission.READ_DEVICE_CONFIG" />
     <uses-permission android:name="android.permission.MODIFY_DAY_NIGHT_MODE" />
+    <uses-permission android:name="android.permission.ACCESS_KEYGUARD_QUICK_AFFORDANCES" />
 
     <queries>
         <!-- Specific intents Wallpaper picker query for -->
@@ -37,6 +38,11 @@
         <intent>
             <action android:name="com.android.launcher3.action.PARTNER_CUSTOMIZATION" />
         </intent>
+        <!-- Intent filter used to query the launcher Activity for grid preview metadata -->
+        <intent>
+            <action android:name="android.intent.action.MAIN" />
+            <category android:name="android.intent.category.HOME" />
+        </intent>
     </queries>
 
     <application
diff --git a/ktfmt_includes.txt b/ktfmt_includes.txt
index 703e852..112b4a1 100644
--- a/ktfmt_includes.txt
+++ b/ktfmt_includes.txt
@@ -1,7 +1,3 @@
 +src/
 +src_override/
 +tests/
--src/com/android/customization/model/color/ColorProvider.kt
--src/com/android/customization/model/color/ColorUtils.kt
--src/com/android/customization/module/SysUiStatsLogger.kt
--src/com/android/customization/picker/clock/ClockSectionView.kt
diff --git a/res/color-night/check_circle_grey_large_not_select_background_color.xml b/res/color-night/check_circle_grey_large_not_select_background_color.xml
index ab5c0cd..32826a7 100644
--- a/res/color-night/check_circle_grey_large_not_select_background_color.xml
+++ b/res/color-night/check_circle_grey_large_not_select_background_color.xml
@@ -14,7 +14,6 @@
      See the License for the specific language governing permissions and
      limitations under the License.
 -->
-<selector xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:androidprv="http://schemas.android.com/apk/prv/res/android">
-    <item android:color="?androidprv:attr/textColorSecondary" />
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:color="@color/text_color_secondary" />
 </selector>
\ No newline at end of file
diff --git a/res/color-night/check_circle_grey_large_not_select_color.xml b/res/color-night/check_circle_grey_large_not_select_color.xml
index 6e8db34..63261b4 100644
--- a/res/color-night/check_circle_grey_large_not_select_color.xml
+++ b/res/color-night/check_circle_grey_large_not_select_color.xml
@@ -14,7 +14,6 @@
      See the License for the specific language governing permissions and
      limitations under the License.
 -->
-<selector xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:androidprv="http://schemas.android.com/apk/prv/res/android" >
-    <item android:color="?androidprv:attr/textColorOnAccent" />
+<selector xmlns:android="http://schemas.android.com/apk/res/android" >
+    <item android:color="@color/text_color_on_accent" />
 </selector>
\ No newline at end of file
diff --git a/res/color-night/option_background_new_selection_color.xml b/res/color-night/option_background_new_selection_color.xml
index 0158ea2..7455a85 100644
--- a/res/color-night/option_background_new_selection_color.xml
+++ b/res/color-night/option_background_new_selection_color.xml
@@ -14,7 +14,6 @@
      See the License for the specific language governing permissions and
      limitations under the License.
 -->
-<selector xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:androidprv="http://schemas.android.com/apk/prv/res/android">
-    <item android:color="?androidprv:attr/colorAccentPrimaryVariant" />
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:color="@color/color_accent_primary_variant" />
 </selector>
\ No newline at end of file
diff --git a/res/color/check_circle_grey_large_not_select_background_color.xml b/res/color/check_circle_grey_large_not_select_background_color.xml
index c023611..4a8a163 100644
--- a/res/color/check_circle_grey_large_not_select_background_color.xml
+++ b/res/color/check_circle_grey_large_not_select_background_color.xml
@@ -14,7 +14,6 @@
      See the License for the specific language governing permissions and
      limitations under the License.
 -->
-<selector xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:androidprv="http://schemas.android.com/apk/prv/res/android">
-    <item android:color="?androidprv:attr/textColorSecondaryInverse" />
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:color="@color/text_color_secondary_inverse" />
 </selector>
\ No newline at end of file
diff --git a/res/color/check_circle_grey_large_not_select_color.xml b/res/color/check_circle_grey_large_not_select_color.xml
index 252665f..e89678a 100644
--- a/res/color/check_circle_grey_large_not_select_color.xml
+++ b/res/color/check_circle_grey_large_not_select_color.xml
@@ -14,7 +14,6 @@
      See the License for the specific language governing permissions and
      limitations under the License.
 -->
-<selector xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:androidprv="http://schemas.android.com/apk/prv/res/android">
-    <item android:color="?androidprv:attr/textColorPrimary" />
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:color="@color/text_color_primary" />
 </selector>
\ No newline at end of file
diff --git a/res/color/keyguard_quick_affordance_slot_tab_background_color.xml b/res/color/keyguard_quick_affordance_slot_tab_background_color.xml
new file mode 100644
index 0000000..4708cef
--- /dev/null
+++ b/res/color/keyguard_quick_affordance_slot_tab_background_color.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?><!--
+  ~ 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.
+  ~
+  -->
+
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:state_selected="true" android:color="@color/color_accent_primary" />
+    <item android:color="@android:color/transparent" />
+</selector>
diff --git a/res/color/keyguard_quick_affordance_slot_tab_text_color.xml b/res/color/keyguard_quick_affordance_slot_tab_text_color.xml
new file mode 100644
index 0000000..84502d4
--- /dev/null
+++ b/res/color/keyguard_quick_affordance_slot_tab_text_color.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?><!--
+  ~ 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.
+  ~
+  -->
+
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:state_selected="true" android:color="@color/text_color_on_accent" />
+    <item android:color="@color/text_color_primary" />
+</selector>
diff --git a/res/color/option_background_new_selection_color.xml b/res/color/option_background_new_selection_color.xml
index 0158ea2..7455a85 100644
--- a/res/color/option_background_new_selection_color.xml
+++ b/res/color/option_background_new_selection_color.xml
@@ -14,7 +14,6 @@
      See the License for the specific language governing permissions and
      limitations under the License.
 -->
-<selector xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:androidprv="http://schemas.android.com/apk/prv/res/android">
-    <item android:color="?androidprv:attr/colorAccentPrimaryVariant" />
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:color="@color/color_accent_primary_variant" />
 </selector>
\ No newline at end of file
diff --git a/res/drawable/beta_tag_background.xml b/res/drawable/beta_tag_background.xml
index 8104531..62a5129 100644
--- a/res/drawable/beta_tag_background.xml
+++ b/res/drawable/beta_tag_background.xml
@@ -14,11 +14,10 @@
      limitations under the License.
 -->
 <shape xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:androidprv="http://schemas.android.com/apk/prv/res/android"
     android:shape="rectangle">
     <size
         android:width="@dimen/beta_tag_background_width"
         android:height="@dimen/beta_tag_background_height" />
     <corners android:radius="@dimen/beta_tag_background_height" />
-    <solid android:color="?androidprv:attr/colorAccentPrimary" />
+    <solid android:color="@color/color_accent_primary" />
 </shape>
\ No newline at end of file
diff --git a/res/drawable/check_circle_grey_large.xml b/res/drawable/check_circle_grey_large.xml
index cf42bf3..f22c910 100644
--- a/res/drawable/check_circle_grey_large.xml
+++ b/res/drawable/check_circle_grey_large.xml
@@ -13,13 +13,12 @@
      See the License for the specific language governing permissions and
      limitations under the License.
 -->
-<layer-list xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:androidprv="http://schemas.android.com/apk/prv/res/android">
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
     <item>
         <shape android:shape="oval">
             <size android:width="@dimen/center_check_size"
                 android:height="@dimen/center_check_size" />
-            <solid android:color="?androidprv:attr/colorAccentPrimaryVariant" />
+            <solid android:color="@color/color_accent_primary_variant" />
         </shape>
     </item>
     <item>
diff --git a/res/drawable/check_circle_grey_large_not_select.xml b/res/drawable/check_circle_grey_large_not_select.xml
index 544d852..bba494e 100644
--- a/res/drawable/check_circle_grey_large_not_select.xml
+++ b/res/drawable/check_circle_grey_large_not_select.xml
@@ -13,8 +13,7 @@
      See the License for the specific language governing permissions and
      limitations under the License.
 -->
-<layer-list xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:androidprv="http://schemas.android.com/apk/prv/res/android">
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
     <item>
         <shape android:shape="oval">
             <size android:width="@dimen/center_check_size"
diff --git a/res/drawable/color_chip_seed_filled0.xml b/res/drawable/color_chip_seed_filled0.xml
index a93bc6b..2d4376c 100644
--- a/res/drawable/color_chip_seed_filled0.xml
+++ b/res/drawable/color_chip_seed_filled0.xml
@@ -19,10 +19,10 @@
     <item>
         <shape android:shape="rectangle">
             <corners
-                android:topLeftRadius="@dimen/component_color_chip_small_size_default" />
+                android:topLeftRadius="@dimen/component_color_chip_small_radius_default" />
             <size
-                android:width="@dimen/component_color_chip_small_size_default"
-                android:height="@dimen/component_color_chip_small_size_default" />
+                android:width="@dimen/component_color_chip_small_radius_default"
+                android:height="@dimen/component_color_chip_small_radius_default" />
             <solid android:color="@android:color/black" />
         </shape>
     </item>
diff --git a/res/drawable/color_chip_seed_filled1.xml b/res/drawable/color_chip_seed_filled1.xml
index a0672bc..1514939 100644
--- a/res/drawable/color_chip_seed_filled1.xml
+++ b/res/drawable/color_chip_seed_filled1.xml
@@ -19,10 +19,10 @@
     <item>
          <shape android:shape="rectangle">
             <corners
-                android:bottomLeftRadius="@dimen/component_color_chip_small_size_default" />
+                android:bottomLeftRadius="@dimen/component_color_chip_small_radius_default" />
             <size
-                android:width="@dimen/component_color_chip_small_size_default"
-                android:height="@dimen/component_color_chip_small_size_default" />
+                android:width="@dimen/component_color_chip_small_radius_default"
+                android:height="@dimen/component_color_chip_small_radius_default" />
             <solid android:color="@android:color/black" />
         </shape>
     </item>
diff --git a/res/drawable/color_chip_seed_filled2.xml b/res/drawable/color_chip_seed_filled2.xml
index 545fbdd..b415bb2 100644
--- a/res/drawable/color_chip_seed_filled2.xml
+++ b/res/drawable/color_chip_seed_filled2.xml
@@ -19,10 +19,10 @@
     <item>
         <shape android:shape="rectangle">
             <corners
-                android:topRightRadius="@dimen/component_color_chip_small_size_default" />
+                android:topRightRadius="@dimen/component_color_chip_small_radius_default" />
             <size
-                android:width="@dimen/component_color_chip_small_size_default"
-                android:height="@dimen/component_color_chip_small_size_default" />
+                android:width="@dimen/component_color_chip_small_radius_default"
+                android:height="@dimen/component_color_chip_small_radius_default" />
             <solid android:color="@android:color/black" />
         </shape>
     </item>
diff --git a/res/drawable/color_chip_seed_filled3.xml b/res/drawable/color_chip_seed_filled3.xml
index 0e286a5..49f429d 100644
--- a/res/drawable/color_chip_seed_filled3.xml
+++ b/res/drawable/color_chip_seed_filled3.xml
@@ -19,10 +19,10 @@
     <item>
         <shape android:shape="rectangle">
             <corners
-                android:bottomRightRadius="@dimen/component_color_chip_small_size_default" />
+                android:bottomRightRadius="@dimen/component_color_chip_small_radius_default" />
             <size
-                android:width="@dimen/component_color_chip_small_size_default"
-                android:height="@dimen/component_color_chip_small_size_default" />
+                android:width="@dimen/component_color_chip_small_radius_default"
+                android:height="@dimen/component_color_chip_small_radius_default" />
             <solid android:color="@android:color/black" />
         </shape>
     </item>
diff --git a/res/drawable/horizontal_divider_14dp.xml b/res/drawable/horizontal_divider_14dp.xml
new file mode 100644
index 0000000..c4c29cf
--- /dev/null
+++ b/res/drawable/horizontal_divider_14dp.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+     Copyright (C) 2021 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">
+    <size
+        android:width="14dp"
+        android:height="0dp" />
+</shape>
diff --git a/res/drawable/keyguard_quick_affordance_icon_container_background.xml b/res/drawable/keyguard_quick_affordance_icon_container_background.xml
new file mode 100644
index 0000000..8bd8af4
--- /dev/null
+++ b/res/drawable/keyguard_quick_affordance_icon_container_background.xml
@@ -0,0 +1,20 @@
+<!--
+     Copyright (C) 2021 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"
+    android:shape="rectangle">
+    <corners android:radius="20dp" />
+    <solid android:color="@color/color_surface_variant" />
+</shape>
diff --git a/res/drawable/keyguard_quick_affordance_icon_container_background_selected.xml b/res/drawable/keyguard_quick_affordance_icon_container_background_selected.xml
new file mode 100644
index 0000000..93a80eb
--- /dev/null
+++ b/res/drawable/keyguard_quick_affordance_icon_container_background_selected.xml
@@ -0,0 +1,34 @@
+<!--
+     Copyright (C) 2021 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"
+    android:shape="rectangle" >
+
+    <stroke
+        android:width="2dp"
+        android:color="@color/text_color_primary" />
+
+    <solid android:color="@color/color_surface_variant" />
+
+    <corners android:radius="20dp" />
+
+    <padding
+        android:left="5dp"
+        android:top="5dp"
+        android:right="5dp"
+        android:bottom="5dp" />
+
+</shape>
diff --git a/res/drawable/keyguard_quick_affordance_picker_background.xml b/res/drawable/keyguard_quick_affordance_picker_background.xml
new file mode 100644
index 0000000..3a49d7a
--- /dev/null
+++ b/res/drawable/keyguard_quick_affordance_picker_background.xml
@@ -0,0 +1,20 @@
+<!--
+     Copyright (C) 2021 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"
+    android:shape="rectangle">
+    <corners android:radius="28dp" />
+    <solid android:color="@color/color_surface" />
+</shape>
diff --git a/res/drawable/keyguard_quick_affordance_slot_tab_background.xml b/res/drawable/keyguard_quick_affordance_slot_tab_background.xml
new file mode 100644
index 0000000..3fbced3
--- /dev/null
+++ b/res/drawable/keyguard_quick_affordance_slot_tab_background.xml
@@ -0,0 +1,20 @@
+<!--
+     Copyright (C) 2021 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"
+    android:shape="rectangle">
+    <corners android:radius="50dp" />
+    <solid android:color="@color/keyguard_quick_affordance_slot_tab_background_color" />
+</shape>
diff --git a/res/drawable/link_off.xml b/res/drawable/link_off.xml
new file mode 100644
index 0000000..f16a63f
--- /dev/null
+++ b/res/drawable/link_off.xml
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?><!--
+  ~ 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.
+  ~
+  -->
+
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="@dimen/keyguard_quick_affordance_icon_size"
+    android:height="@dimen/keyguard_quick_affordance_icon_size"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M14.39,11L16,12.61V11zM17,7h-4v1.9h4c1.71,0 3.1,1.39 3.1,3.1 0,1.27 -0.77,2.37 -1.87,2.84l1.4,1.4C21.05,15.36 22,13.79 22,12c0,-2.76 -2.24,-5 -5,-5zM2,4.27l3.11,3.11C3.29,8.12 2,9.91 2,12c0,2.76 2.24,5 5,5h4v-1.9H7c-1.71,0 -3.1,-1.39 -3.1,-3.1 0,-1.59 1.21,-2.9 2.76,-3.07L8.73,11H8v2h2.73L13,15.27V17h1.73l4.01,4.01 1.41,-1.41L3.41,2.86 2,4.27z"/>
+</vector>
diff --git a/res/drawable/option_border.xml b/res/drawable/option_border.xml
index 6a9d5e9..d0fde5c 100644
--- a/res/drawable/option_border.xml
+++ b/res/drawable/option_border.xml
@@ -14,7 +14,6 @@
      limitations under the License.
 -->
 <ripple xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:androidprv="http://schemas.android.com/apk/prv/res/android"
     android:color="?android:attr/colorControlHighlight">
     <item android:id="@android:id/mask">
         <shape android:shape="rectangle">
@@ -24,7 +23,7 @@
     </item>
     <item>
         <shape android:shape="rectangle">
-            <solid android:color="?androidprv:attr/colorSurface"/>
+            <solid android:color="@color/color_surface"/>
             <corners android:radius="@dimen/option_tile_radius" />
         </shape>
     </item>
diff --git a/res/drawable/option_border_color.xml b/res/drawable/option_border_color.xml
index ba5097b..cecb001 100644
--- a/res/drawable/option_border_color.xml
+++ b/res/drawable/option_border_color.xml
@@ -14,17 +14,16 @@
      limitations under the License.
 -->
 <ripple xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:androidprv="http://schemas.android.com/apk/prv/res/android"
     android:color="?android:attr/colorControlHighlight">
     <item android:id="@+id/systempalettecolor">
         <shape android:shape="rectangle">
-            <solid android:color="?androidprv:attr/colorSurface"/>
+            <solid android:color="@color/color_surface"/>
             <corners android:radius="@dimen/option_tile_radius" />
         </shape>
     </item>
     <item android:id="@android:id/mask">
         <shape android:shape="rectangle">
-            <solid android:color="?androidprv:attr/colorSurface"/>
+            <solid android:color="@color/color_surface"/>
             <corners android:radius="@dimen/option_tile_radius" />
         </shape>
     </item>
diff --git a/res/drawable/option_border_new_selection.xml b/res/drawable/option_border_new_selection.xml
index 6c02caa..8045f17 100644
--- a/res/drawable/option_border_new_selection.xml
+++ b/res/drawable/option_border_new_selection.xml
@@ -14,7 +14,6 @@
      limitations under the License.
 -->
 <ripple xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:androidprv="http://schemas.android.com/apk/prv/res/android"
     android:color="?android:attr/colorControlHighlight">
     <item android:id="@android:id/mask">
         <shape android:shape="rectangle">
diff --git a/res/drawable/selectable.xml b/res/drawable/selectable.xml
new file mode 100644
index 0000000..1364d68
--- /dev/null
+++ b/res/drawable/selectable.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?><!--
+  ~ 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.
+  ~
+  -->
+
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:state_selected="true" android:drawable="@drawable/selectable_selected" />
+    <item android:drawable="@android:color/transparent" />
+</selector>
diff --git a/res/drawable/selectable_selected.xml b/res/drawable/selectable_selected.xml
new file mode 100644
index 0000000..2ba8948
--- /dev/null
+++ b/res/drawable/selectable_selected.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?><!--
+  ~ 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.
+  ~
+  -->
+
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+    android:shape="rectangle">
+    <corners android:radius="8dp" />
+    <stroke android:width="2dp" android:color="@android:color/white" />
+</shape>
diff --git a/res/layout/check_circle_grey_large_not_select_background_color.xml b/res/layout/check_circle_grey_large_not_select_background_color.xml
index c023611..4a8a163 100644
--- a/res/layout/check_circle_grey_large_not_select_background_color.xml
+++ b/res/layout/check_circle_grey_large_not_select_background_color.xml
@@ -14,7 +14,6 @@
      See the License for the specific language governing permissions and
      limitations under the License.
 -->
-<selector xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:androidprv="http://schemas.android.com/apk/prv/res/android">
-    <item android:color="?androidprv:attr/textColorSecondaryInverse" />
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:color="@color/text_color_secondary_inverse" />
 </selector>
\ No newline at end of file
diff --git a/res/layout/clock_section_view.xml b/res/layout/clock_section_view.xml
index d95e651..8512498 100644
--- a/res/layout/clock_section_view.xml
+++ b/res/layout/clock_section_view.xml
@@ -49,6 +49,7 @@
         android:scaleType="center"
         android:src="@drawable/ic_clock_24px"
         android:background="@drawable/option_border_color"
-        android:contentDescription="@string/clock_picker_entry_content_description" />
+        android:contentDescription="@string/clock_picker_entry_content_description"
+        android:tint="@color/text_color_primary" />
 
 </com.android.customization.picker.clock.ClockSectionView>
\ No newline at end of file
diff --git a/res/layout/color_option.xml b/res/layout/color_option.xml
index 9bbfd7f..d9a7136 100644
--- a/res/layout/color_option.xml
+++ b/res/layout/color_option.xml
@@ -1,5 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
+<?xml version="1.0" encoding="utf-8"?><!--
      Copyright (C) 2022 The Android Open Source Project
 
      Licensed under the Apache License, Version 2.0 (the "License");
@@ -14,50 +13,91 @@
      See the License for the specific language governing permissions and
      limitations under the License.
 -->
-<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
+<!-- Enclosing layout must be match_parent so that we can center content within -->
+<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
     android:layout_width="match_parent"
     android:layout_height="wrap_content"
+    android:layout_gravity="center"
     android:clipChildren="false"
-    android:clipToPadding="false"
-    android:orientation="vertical">
+    android:gravity="center"
+    android:padding="@dimen/option_tile_grid_tile_padding_min">
 
-    <FrameLayout
-        android:id="@+id/option_tile"
-        android:layout_width="@dimen/option_tile_width"
-        android:layout_height="@dimen/option_tile_width"
-        android:layout_gravity="center_horizontal"
-        android:background="@drawable/option_border_color">
-        <ImageView
-            android:id="@+id/color_preview_0"
-            android:layout_width="wrap_content"
-            android:layout_height="wrap_content"
+    <!--
+        This displays the background. It is dynamically sized, constrained remain square and
+        have a maximum size, and be centered within its parent.
+     -->
+    <androidx.constraintlayout.widget.ConstraintLayout
+        android:layout_width="0dp"
+        android:layout_height="0dp"
+        android:layout_gravity="center"
+        android:background="@drawable/option_border_color"
+        android:gravity="center"
+        android:padding="@dimen/option_tile_grid_icon_padding_min"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintDimensionRatio="1:1"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintTop_toTopOf="parent"
+        app:layout_constraintWidth_max="@dimen/option_tile_width">
+
+        <!-- This is the color wheel itself, constrained to a maximum size and centered -->
+        <androidx.constraintlayout.widget.ConstraintLayout
+            android:id="@+id/option_tile"
+            android:layout_width="0dp"
+            android:layout_height="0dp"
             android:layout_gravity="center"
-            android:layout_marginRight="@dimen/color_seed_chip_margin"
-            android:layout_marginBottom="@dimen/color_seed_chip_margin"
-            android:src="@drawable/color_chip_seed_filled0"/>
-        <ImageView
-            android:id="@+id/color_preview_1"
-            android:layout_width="wrap_content"
-            android:layout_height="wrap_content"
-            android:layout_gravity="center"
-            android:layout_marginLeft="@dimen/color_seed_chip_margin"
-            android:layout_marginBottom="@dimen/color_seed_chip_margin"
-            android:src="@drawable/color_chip_seed_filled2"/>
-        <ImageView
-            android:id="@+id/color_preview_2"
-            android:layout_width="wrap_content"
-            android:layout_height="wrap_content"
-            android:layout_gravity="center"
-            android:layout_marginRight="@dimen/color_seed_chip_margin"
-            android:layout_marginTop="@dimen/color_seed_chip_margin"
-            android:src="@drawable/color_chip_seed_filled1"/>
-        <ImageView
-            android:id="@+id/color_preview_3"
-            android:layout_width="wrap_content"
-            android:layout_height="wrap_content"
-            android:layout_gravity="center"
-            android:layout_marginLeft="@dimen/color_seed_chip_margin"
-            android:layout_marginTop="@dimen/color_seed_chip_margin"
-            android:src="@drawable/color_chip_seed_filled3"/>
-    </FrameLayout>
-</FrameLayout>
+            android:gravity="center"
+            app:layout_constraintBottom_toBottomOf="parent"
+            app:layout_constraintEnd_toEndOf="parent"
+            app:layout_constraintHeight_max="@dimen/component_color_chip_small_diameter_default"
+            app:layout_constraintStart_toStartOf="parent"
+            app:layout_constraintTop_toTopOf="parent"
+            app:layout_constraintWidth_max="@dimen/component_color_chip_small_diameter_default">
+
+            <ImageView
+                android:id="@+id/color_preview_0"
+                android:layout_width="0dp"
+                android:layout_height="0dp"
+                android:adjustViewBounds="true"
+                android:src="@drawable/color_chip_seed_filled0"
+                app:layout_constraintHeight_percent=".50"
+                app:layout_constraintLeft_toLeftOf="parent"
+                app:layout_constraintTop_toTopOf="parent"
+                app:layout_constraintWidth_percent=".50" />
+
+            <ImageView
+                android:id="@+id/color_preview_1"
+                android:layout_width="0dp"
+                android:layout_height="0dp"
+                android:adjustViewBounds="true"
+                android:src="@drawable/color_chip_seed_filled2"
+                app:layout_constraintHeight_percent=".50"
+                app:layout_constraintLeft_toRightOf="@id/color_preview_0"
+                app:layout_constraintTop_toTopOf="parent"
+                app:layout_constraintWidth_percent=".50" />
+
+            <ImageView
+                android:id="@+id/color_preview_2"
+                android:layout_width="0dp"
+                android:layout_height="0dp"
+                android:adjustViewBounds="true"
+                android:src="@drawable/color_chip_seed_filled1"
+                app:layout_constraintHeight_percent=".50"
+                app:layout_constraintLeft_toLeftOf="parent"
+                app:layout_constraintTop_toBottomOf="@id/color_preview_0"
+                app:layout_constraintWidth_percent=".50" />
+
+            <ImageView
+                android:id="@+id/color_preview_3"
+                android:layout_width="0dp"
+                android:layout_height="0dp"
+                android:adjustViewBounds="true"
+                android:src="@drawable/color_chip_seed_filled3"
+                app:layout_constraintHeight_percent=".50"
+                app:layout_constraintLeft_toRightOf="@id/color_preview_2"
+                app:layout_constraintTop_toBottomOf="@id/color_preview_1"
+                app:layout_constraintWidth_percent=".50" />
+        </androidx.constraintlayout.widget.ConstraintLayout>
+    </androidx.constraintlayout.widget.ConstraintLayout>
+</androidx.constraintlayout.widget.ConstraintLayout>
diff --git a/res/layout/fragment_lock_screen_quick_affordances.xml b/res/layout/fragment_lock_screen_quick_affordances.xml
new file mode 100644
index 0000000..9927e6a
--- /dev/null
+++ b/res/layout/fragment_lock_screen_quick_affordances.xml
@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="utf-8"?><!--
+  ~ 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.
+  ~
+  -->
+
+<LinearLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="vertical">
+
+    <FrameLayout
+        android:id="@+id/section_header_container"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content">
+
+        <include layout="@layout/section_header" />
+
+    </FrameLayout>
+
+    <!-- TODO(b/254858701): plug in the preview here. -->
+    <View
+        android:layout_width="match_parent"
+        android:layout_height="0dp"
+        android:layout_weight="1" />
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:orientation="vertical"
+        android:layout_marginHorizontal="24dp"
+        android:layout_marginBottom="28dp"
+        android:background="@drawable/keyguard_quick_affordance_picker_background"
+        android:paddingTop="22dp"
+        android:paddingBottom="62dp">
+
+        <androidx.recyclerview.widget.RecyclerView
+            android:id="@id/slot_tabs"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:clipToPadding="false"
+            android:paddingHorizontal="16dp" />
+
+        <View
+            android:layout_width="0dp"
+            android:layout_height="22dp" />
+
+        <androidx.recyclerview.widget.RecyclerView
+            android:id="@id/affordances"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:clipToPadding="false"
+            android:paddingHorizontal="16dp" />
+
+    </LinearLayout>
+
+</LinearLayout>
diff --git a/res/layout/keyguard_quick_affordance.xml b/res/layout/keyguard_quick_affordance.xml
new file mode 100644
index 0000000..90ba68e
--- /dev/null
+++ b/res/layout/keyguard_quick_affordance.xml
@@ -0,0 +1,53 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ 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.
+  ~
+  -->
+
+<LinearLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:layout_width="@dimen/keyguard_quick_affordance_picker_item_width"
+    android:layout_height="wrap_content"
+    android:orientation="vertical"
+    android:gravity="center_horizontal">
+
+    <FrameLayout
+        android:id="@+id/icon_container"
+        android:layout_width="@dimen/keyguard_quick_affordance_icon_container_size"
+        android:layout_height="@dimen/keyguard_quick_affordance_icon_container_size" >
+
+        <ImageView
+            android:id="@+id/icon"
+            android:layout_width="@dimen/keyguard_quick_affordance_icon_size"
+            android:layout_height="@dimen/keyguard_quick_affordance_icon_size"
+            android:layout_gravity="center"
+            android:tint="@color/text_color_primary" />
+
+    </FrameLayout>
+
+    <View
+        android:layout_width="0dp"
+        android:layout_height="8dp" />
+
+    <TextView
+        android:id="@+id/name"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:textColor="@color/text_color_primary"
+        android:singleLine="true"
+        android:ellipsize="end"/>
+
+</LinearLayout>
\ No newline at end of file
diff --git a/res/layout/keyguard_quick_affordance_section_view.xml b/res/layout/keyguard_quick_affordance_section_view.xml
new file mode 100644
index 0000000..458f659
--- /dev/null
+++ b/res/layout/keyguard_quick_affordance_section_view.xml
@@ -0,0 +1,73 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+     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.
+-->
+<com.android.customization.picker.quickaffordance.ui.view.KeyguardQuickAffordanceSectionView
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:background="?selectableItemBackground"
+    android:clickable="true"
+    android:paddingVertical="@dimen/section_top_padding"
+    android:paddingHorizontal="@dimen/section_horizontal_padding"
+    android:orientation="horizontal">
+
+    <LinearLayout
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:layout_weight="1"
+        android:orientation="vertical">
+
+        <TextView
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:text="@string/keyguard_quick_affordance_section_title"
+            style="@style/SectionTitleTextStyle" />
+
+        <TextView
+            android:id="@+id/keyguard_quick_affordance_description"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            style="@style/SectionSubtitleTextStyle"/>
+    </LinearLayout>
+
+    <LinearLayout
+        android:layout_width="@dimen/option_tile_width"
+        android:layout_height="@dimen/option_tile_width"
+        android:orientation="horizontal"
+        android:background="@drawable/option_border_color"
+        android:importantForAccessibility="noHideDescendants"
+        android:gravity="center"
+        android:divider="@drawable/horizontal_divider_14dp"
+        android:showDividers="middle">
+
+        <ImageView
+            android:id="@+id/icon_1"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:visibility="gone"
+            android:tint="@color/text_color_primary" />
+
+        <ImageView
+            android:id="@+id/icon_2"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:visibility="gone"
+            android:tint="@color/text_color_primary" />
+
+    </LinearLayout>
+
+
+</com.android.customization.picker.quickaffordance.ui.view.KeyguardQuickAffordanceSectionView>
\ No newline at end of file
diff --git a/res/layout/keyguard_quick_affordance_slot_tab.xml b/res/layout/keyguard_quick_affordance_slot_tab.xml
new file mode 100644
index 0000000..ba233cd
--- /dev/null
+++ b/res/layout/keyguard_quick_affordance_slot_tab.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="utf-8"?><!--
+  ~ 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.
+  ~
+  -->
+
+<TextView
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/text"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:textColor="@color/keyguard_quick_affordance_slot_tab_text_color"
+    android:paddingVertical="8dp"
+    android:paddingHorizontal="16dp"
+    android:minWidth="48dp"
+    android:minHeight="48dp"
+    android:gravity="center"
+    android:background="@drawable/keyguard_quick_affordance_slot_tab_background" />
diff --git a/res/layout/themed_icon_section_view.xml b/res/layout/themed_icon_section_view.xml
index cf7b842..95be207 100644
--- a/res/layout/themed_icon_section_view.xml
+++ b/res/layout/themed_icon_section_view.xml
@@ -16,7 +16,6 @@
 -->
 <com.android.customization.picker.themedicon.ThemedIconSectionView
     xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:androidprv="http://schemas.android.com/apk/prv/res/android"
     android:layout_width="match_parent"
     android:layout_height="wrap_content"
     android:background="?selectableItemBackground"
@@ -63,7 +62,7 @@
         android:paddingHorizontal="8dp"
         android:paddingVertical="4dp"
         android:text="@string/beta_title"
-        android:textColor="?androidprv:attr/textColorOnAccent"
+        android:textColor="@color/text_color_on_accent"
         style="@style/BetaTagTextStyle" />
 
 </com.android.customization.picker.themedicon.ThemedIconSectionView>
diff --git a/res/values-af/strings.xml b/res/values-af/strings.xml
index 9cda091..4a6733e 100644
--- a/res/values-af/strings.xml
+++ b/res/values-af/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Muurpapier en styl"</string>
     <string name="theme_title" msgid="2144932106319405101">"Styl"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Gepasmaakte horlosie"</string>
-    <string name="clock_description" msgid="3563839327378948">"Kies gepasmaakte horlosie"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Verander ’n gepasmaakte horlosie"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Horlosie"</string>
     <string name="grid_title" msgid="1688173478777254123">"Programrooster"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Pas toe"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Tik om te wysig"</string>
diff --git a/res/values-am/strings.xml b/res/values-am/strings.xml
index 8a8a533..7399eca 100644
--- a/res/values-am/strings.xml
+++ b/res/values-am/strings.xml
@@ -17,11 +17,9 @@
 
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="app_name" msgid="1647136562008520313">"ልጣፍ እና ቅጥ"</string>
+    <string name="app_name" msgid="1647136562008520313">"ልጣፍ &amp; ቅጥ"</string>
     <string name="theme_title" msgid="2144932106319405101">"ቅጥ"</string>
-    <string name="clock_title" msgid="1974314575211361352">"ብጁ ሰዓት"</string>
-    <string name="clock_description" msgid="3563839327378948">"ብጁ ሰዓት ይምረጡ"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"ብጁ ሰዓትን ይለውጡ"</string>
+    <string name="clock_title" msgid="2126046720254613991">"ሰዓት"</string>
     <string name="grid_title" msgid="1688173478777254123">"የመተግበሪያ ፍርግርግ"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"ተግብር"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"ለማርትዕ መታ ያድርጉ"</string>
diff --git a/res/values-ar/strings.xml b/res/values-ar/strings.xml
index 50ed34d..ef802d2 100644
--- a/res/values-ar/strings.xml
+++ b/res/values-ar/strings.xml
@@ -17,11 +17,9 @@
 
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="app_name" msgid="1647136562008520313">"الخلفية والأسلوب"</string>
+    <string name="app_name" msgid="1647136562008520313">"الخلفية والنمط"</string>
     <string name="theme_title" msgid="2144932106319405101">"النمط"</string>
-    <string name="clock_title" msgid="1974314575211361352">"خلفية شاشة ساعة مخصّصة"</string>
-    <string name="clock_description" msgid="3563839327378948">"اختيار خلفية شاشة ساعة مخصّصة"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"تغيير خلفية شاشة ساعة مخصّصة"</string>
+    <string name="clock_title" msgid="2126046720254613991">"الساعة"</string>
     <string name="grid_title" msgid="1688173478777254123">"شبكة التطبيقات"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"تطبيق"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"انقُر للتعديل."</string>
diff --git a/res/values-as/strings.xml b/res/values-as/strings.xml
index 74fd947..81c77f0 100644
--- a/res/values-as/strings.xml
+++ b/res/values-as/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"ৱালপেপাৰ আৰু শৈলী"</string>
     <string name="theme_title" msgid="2144932106319405101">"শৈলী"</string>
-    <string name="clock_title" msgid="1974314575211361352">"কাষ্টম ঘড়ী"</string>
-    <string name="clock_description" msgid="3563839327378948">"কাষ্টম ঘড়ী বাছক"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"কাষ্টম ঘড়ী সলনি কৰক"</string>
+    <string name="clock_title" msgid="2126046720254613991">"ঘড়ী"</string>
     <string name="grid_title" msgid="1688173478777254123">"এপৰ গ্ৰিড"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"প্ৰয়োগ কৰক"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"সম্পাদনা কৰিবলৈ টিপক"</string>
@@ -44,7 +42,7 @@
     <string name="preview_name_shape" msgid="5676971146080968721">"আকৃতি"</string>
     <string name="preview_name_wallpaper" msgid="1738652462949531828">"ৱালপেপাৰ"</string>
     <string name="font_card_title" msgid="2343292653502548685">"ABC • abc • 123"</string>
-    <string name="font_card_body" msgid="6790525594503904468">"প্ৰত্যেকখন স্ক্ৰীনত আপোনাৰ প্ৰিয় ফ’ণ্ট যোগ দিয়ক"</string>
+    <string name="font_card_body" msgid="6790525594503904468">"প্ৰত্যেকখন স্ক্ৰীণত আপোনাৰ প্ৰিয় ফণ্ট যোগ কৰক"</string>
     <string name="grid_options_title" msgid="7071930966989877023">"এটা গ্ৰিডৰ আকাৰ বাছনি কৰক"</string>
     <string name="grid_title_pattern" msgid="9188866567612607806">"<xliff:g id="ID_1">%1$d</xliff:g>x<xliff:g id="ID_2">%2$d</xliff:g>"</string>
     <string name="applied_theme_msg" msgid="3749018706366796244">"শৈলী সফলতাৰে ছেট কৰা হ’ল"</string>
diff --git a/res/values-az/strings.xml b/res/values-az/strings.xml
index 79ecb46..2d8209b 100644
--- a/res/values-az/strings.xml
+++ b/res/values-az/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Divar kağızı və üslub"</string>
     <string name="theme_title" msgid="2144932106319405101">"Üslub"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Fərdi Saat"</string>
-    <string name="clock_description" msgid="3563839327378948">"Fərdi saat seç"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Fərdi saatı dəyişdir"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Saat"</string>
     <string name="grid_title" msgid="1688173478777254123">"Tətbiq toru"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Tətbiq edin"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Redaktə etmək üçün klikləyin"</string>
diff --git a/res/values-b+sr+Latn/strings.xml b/res/values-b+sr+Latn/strings.xml
index 713cea8..d8aacd6 100644
--- a/res/values-b+sr+Latn/strings.xml
+++ b/res/values-b+sr+Latn/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Pozadina i stil"</string>
     <string name="theme_title" msgid="2144932106319405101">"Stil"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Prilagođeni sat"</string>
-    <string name="clock_description" msgid="3563839327378948">"Prilagođeni sat"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Promenite prilagođeni sat"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Sat"</string>
     <string name="grid_title" msgid="1688173478777254123">"Mreža apl."</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Primeni"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Dodirnite da biste izmenili"</string>
diff --git a/res/values-be/strings.xml b/res/values-be/strings.xml
index d23f607..4151478 100644
--- a/res/values-be/strings.xml
+++ b/res/values-be/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Шпалеры і стыль"</string>
     <string name="theme_title" msgid="2144932106319405101">"Стыль"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Гадзіннік"</string>
-    <string name="clock_description" msgid="3563839327378948">"Выбар цыферблата"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Змяненне цыферблата"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Гадзіннік"</string>
     <string name="grid_title" msgid="1688173478777254123">"Сетка праграм"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Ужыць"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Дакраніцеся, каб рэдагаваць"</string>
diff --git a/res/values-bg/strings.xml b/res/values-bg/strings.xml
index 21d5ac0..849af69 100644
--- a/res/values-bg/strings.xml
+++ b/res/values-bg/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Тапет и стил"</string>
     <string name="theme_title" msgid="2144932106319405101">"Стил"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Персонал. циферблат"</string>
-    <string name="clock_description" msgid="3563839327378948">"Персон. циферблат: Избор"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Промяна на персонализиран циферблат"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Часовник"</string>
     <string name="grid_title" msgid="1688173478777254123">"Решетка с прил."</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Прилагане"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Докоснете, за да редактирате"</string>
diff --git a/res/values-bn/strings.xml b/res/values-bn/strings.xml
index 25241a8..b1c9abe 100644
--- a/res/values-bn/strings.xml
+++ b/res/values-bn/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"ওয়ালপেপার এবং স্টাইল"</string>
     <string name="theme_title" msgid="2144932106319405101">"স্টাইল"</string>
-    <string name="clock_title" msgid="1974314575211361352">"কাস্টম ঘড়ি"</string>
-    <string name="clock_description" msgid="3563839327378948">"কাস্টম ঘড়ি বেছে নিন"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"কাস্টম ঘড়ি পরিবর্তন করুন"</string>
+    <string name="clock_title" msgid="2126046720254613991">"ঘড়ি"</string>
     <string name="grid_title" msgid="1688173478777254123">"অ্যাপ গ্রিড"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"প্রয়োগ করুন"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"এডিট করতে ট্যাপ করুন"</string>
diff --git a/res/values-bs/strings.xml b/res/values-bs/strings.xml
index 901ac78..11c4587 100644
--- a/res/values-bs/strings.xml
+++ b/res/values-bs/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Pozadinska slika i stil"</string>
     <string name="theme_title" msgid="2144932106319405101">"Stil"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Prilagođeni sat"</string>
-    <string name="clock_description" msgid="3563839327378948">"Odabir prilagođ. sata"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Promijenite prilagođeni sat"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Sat"</string>
     <string name="grid_title" msgid="1688173478777254123">"Mreža aplikacija"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Primijeni"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Dodirnite da uredite"</string>
diff --git a/res/values-ca/strings.xml b/res/values-ca/strings.xml
index fa26aa9..f9a3a33 100644
--- a/res/values-ca/strings.xml
+++ b/res/values-ca/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Estil i fons de pantalla"</string>
     <string name="theme_title" msgid="2144932106319405101">"Estil"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Rellotge pers."</string>
-    <string name="clock_description" msgid="3563839327378948">"Tria rellotge pers."</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Canvia un rellotge personalitzat"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Rellotge"</string>
     <string name="grid_title" msgid="1688173478777254123">"Quadrícula d\'apps"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Aplica"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Toca per editar"</string>
diff --git a/res/values-cs/strings.xml b/res/values-cs/strings.xml
index 5bee171..3bdbe89 100644
--- a/res/values-cs/strings.xml
+++ b/res/values-cs/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Tapeta a styl"</string>
     <string name="theme_title" msgid="2144932106319405101">"Styl"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Vlastní hodiny"</string>
-    <string name="clock_description" msgid="3563839327378948">"Výběr vlastních hodin"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Změna vlastních hodin"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Hodiny"</string>
     <string name="grid_title" msgid="1688173478777254123">"Mřížka aplikací"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Použít"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Klepnutím upravte"</string>
diff --git a/res/values-da/strings.xml b/res/values-da/strings.xml
index 46f319b..68fe7b3 100644
--- a/res/values-da/strings.xml
+++ b/res/values-da/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Baggrund og stil"</string>
     <string name="theme_title" msgid="2144932106319405101">"Stil"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Tilpasset ur"</string>
-    <string name="clock_description" msgid="3563839327378948">"Vælg tilpasset ur"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Juster et tilpasset ur"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Ur"</string>
     <string name="grid_title" msgid="1688173478777254123">"Appgitter"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Anvend"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Tryk for at redigere"</string>
diff --git a/res/values-de/strings.xml b/res/values-de/strings.xml
index 3bc3532..c55bffb 100644
--- a/res/values-de/strings.xml
+++ b/res/values-de/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Hintergrund &amp; Stil"</string>
     <string name="theme_title" msgid="2144932106319405101">"Design"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Benutzerdefinierte Uhr"</string>
-    <string name="clock_description" msgid="3563839327378948">"Benutzerdefinierte Uhr wählen"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Benutzerdefinierte Uhr ändern"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Uhr"</string>
     <string name="grid_title" msgid="1688173478777254123">"App-Raster"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Anwenden"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Zum Bearbeiten tippen"</string>
diff --git a/res/values-el/strings.xml b/res/values-el/strings.xml
index 5fe9043..db4400f 100644
--- a/res/values-el/strings.xml
+++ b/res/values-el/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Ταπετσαρία και στιλ"</string>
     <string name="theme_title" msgid="2144932106319405101">"Στιλ"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Προσαρ. ρολόι"</string>
-    <string name="clock_description" msgid="3563839327378948">"Επιλογή προσαρ. ρολογιού"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Αλλαγή προσαρ. ρολογιού"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Ρολόι"</string>
     <string name="grid_title" msgid="1688173478777254123">"Πλέγμα εφαρμ."</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Εφαρμογή"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Πατήστε για επεξεργασία"</string>
diff --git a/res/values-en-rAU/strings.xml b/res/values-en-rAU/strings.xml
index 6a8ca3d..1d78ca0 100644
--- a/res/values-en-rAU/strings.xml
+++ b/res/values-en-rAU/strings.xml
@@ -17,11 +17,9 @@
 
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="app_name" msgid="1647136562008520313">"Wallpaper and style"</string>
+    <string name="app_name" msgid="1647136562008520313">"Wallpaper &amp; style"</string>
     <string name="theme_title" msgid="2144932106319405101">"Style"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Custom clock"</string>
-    <string name="clock_description" msgid="3563839327378948">"Pick a custom clock"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Change a custom clock"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Clock"</string>
     <string name="grid_title" msgid="1688173478777254123">"App grid"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Apply"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Tap to edit"</string>
diff --git a/res/values-en-rCA/strings.xml b/res/values-en-rCA/strings.xml
index 6a8ca3d..1d78ca0 100644
--- a/res/values-en-rCA/strings.xml
+++ b/res/values-en-rCA/strings.xml
@@ -17,11 +17,9 @@
 
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="app_name" msgid="1647136562008520313">"Wallpaper and style"</string>
+    <string name="app_name" msgid="1647136562008520313">"Wallpaper &amp; style"</string>
     <string name="theme_title" msgid="2144932106319405101">"Style"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Custom clock"</string>
-    <string name="clock_description" msgid="3563839327378948">"Pick a custom clock"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Change a custom clock"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Clock"</string>
     <string name="grid_title" msgid="1688173478777254123">"App grid"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Apply"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Tap to edit"</string>
diff --git a/res/values-en-rGB/strings.xml b/res/values-en-rGB/strings.xml
index 6a8ca3d..1d78ca0 100644
--- a/res/values-en-rGB/strings.xml
+++ b/res/values-en-rGB/strings.xml
@@ -17,11 +17,9 @@
 
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="app_name" msgid="1647136562008520313">"Wallpaper and style"</string>
+    <string name="app_name" msgid="1647136562008520313">"Wallpaper &amp; style"</string>
     <string name="theme_title" msgid="2144932106319405101">"Style"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Custom clock"</string>
-    <string name="clock_description" msgid="3563839327378948">"Pick a custom clock"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Change a custom clock"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Clock"</string>
     <string name="grid_title" msgid="1688173478777254123">"App grid"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Apply"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Tap to edit"</string>
diff --git a/res/values-en-rIN/strings.xml b/res/values-en-rIN/strings.xml
index 6a8ca3d..1d78ca0 100644
--- a/res/values-en-rIN/strings.xml
+++ b/res/values-en-rIN/strings.xml
@@ -17,11 +17,9 @@
 
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="app_name" msgid="1647136562008520313">"Wallpaper and style"</string>
+    <string name="app_name" msgid="1647136562008520313">"Wallpaper &amp; style"</string>
     <string name="theme_title" msgid="2144932106319405101">"Style"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Custom clock"</string>
-    <string name="clock_description" msgid="3563839327378948">"Pick a custom clock"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Change a custom clock"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Clock"</string>
     <string name="grid_title" msgid="1688173478777254123">"App grid"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Apply"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Tap to edit"</string>
diff --git a/res/values-en-rXC/strings.xml b/res/values-en-rXC/strings.xml
index 0dea21b..8ed71cd 100644
--- a/res/values-en-rXC/strings.xml
+++ b/res/values-en-rXC/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‏‎‎‎‎‎‎‎‏‏‏‏‏‏‏‏‎‏‏‎‏‏‎‏‏‎‏‏‎‏‏‏‏‎‎‏‏‎‏‏‏‏‏‏‎‎‏‏‏‏‎‏‎‏‏‎‎‎‏‎‎‏‏‎‏‏‏‎‏‏‎‎‏‏‏‏‎‎‏‎Wallpaper &amp; style‎‏‎‎‏‎"</string>
     <string name="theme_title" msgid="2144932106319405101">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‏‎‎‎‎‎‎‎‏‏‏‏‏‏‏‏‎‏‏‏‏‎‏‏‏‎‎‎‏‎‎‎‏‎‏‎‏‎‎‎‏‏‎‎‎‏‎‏‏‏‎‏‎‎‎‎‏‏‏‏‏‏‏‏‎‏‎‎‎‎‎‎‎‏‎‏‏‎‏‎Style‎‏‎‎‏‎"</string>
-    <string name="clock_title" msgid="1974314575211361352">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‏‎‎‎‎‎‎‎‏‏‏‏‏‏‏‏‎‏‏‏‎‏‏‎‏‏‎‎‏‏‎‎‎‏‎‏‏‎‎‏‎‏‎‎‏‎‏‎‏‎‏‎‎‏‎‎‏‎‏‏‎‎‏‎‏‏‏‎‏‎‎‎‏‎‎‏‎‎‎‎Custom Clock‎‏‎‎‏‎"</string>
-    <string name="clock_description" msgid="3563839327378948">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‏‎‎‎‎‎‎‎‏‏‏‏‏‏‎‏‎‎‏‏‎‎‏‎‏‎‏‎‎‏‎‏‎‎‏‎‏‏‎‎‎‎‎‎‎‏‎‎‏‎‎‏‎‏‎‎‎‏‏‏‏‎‎‎‎‎‎‏‎‎‎Pick a custom clock‎‏‎‎‏‎"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‏‎‎‎‎‎‎‎‏‏‏‏‏‏‏‏‏‏‏‏‏‎‏‎‎‎‏‎‎‎‎‎‏‏‎‎‏‎‎‏‏‏‏‎‎‏‎‎‏‎‎‎‎‎‏‎‏‎‎‎‏‎‎‎‏‏‏‎‎‏‏‏‎‎‎‎‏‎‏‏‎‎Change a custom clock‎‏‎‎‏‎"</string>
+    <string name="clock_title" msgid="2126046720254613991">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‏‎‎‎‎‎‎‎‏‏‏‏‏‏‏‏‎‏‏‏‏‎‏‏‎‎‎‎‎‎‏‎‎‏‏‏‏‎‎‎‎‏‏‏‎‏‎‎‏‎‏‎‎‎‎‏‎‏‎‏‎‎‏‎‎‎‏‏‎‎‏‏‏‏‎‎‏‏‏‎Clock‎‏‎‎‏‎"</string>
     <string name="grid_title" msgid="1688173478777254123">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‏‎‎‎‎‎‎‎‏‏‏‏‏‏‏‏‎‏‏‎‏‏‏‎‏‏‎‏‏‎‏‏‎‎‏‏‎‎‎‏‏‎‏‎‏‎‏‏‎‏‎‏‎‎‏‏‏‎‎‎‎‎‎‏‏‏‏‎‎‎‎‏‏‏‎‏‎‏‏‎App grid‎‏‎‎‏‎"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‏‎‎‎‎‎‎‎‏‏‏‏‏‏‏‏‏‏‏‎‏‎‏‏‏‎‏‎‏‎‏‎‏‏‎‎‎‎‏‎‎‎‎‎‎‎‎‎‎‏‎‎‏‎‎‏‏‎‎‎‎‎‎‎‎‏‏‎‎‎‏‎‏‏‎‏‏‎‏‏‏‎Apply‎‏‎‎‏‎"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‏‎‎‎‎‎‎‎‏‏‏‏‏‏‏‏‏‏‏‎‎‏‎‎‎‎‏‎‏‎‎‏‎‏‎‎‎‏‎‎‎‎‏‏‎‏‎‎‏‏‎‎‎‏‎‏‏‎‏‎‎‎‏‏‏‏‏‏‎‏‎‏‏‏‎‏‏‏‎‎‎‎Tap to edit‎‏‎‎‏‎"</string>
diff --git a/res/values-es-rUS/strings.xml b/res/values-es-rUS/strings.xml
index c6e1938..0eb30c7 100644
--- a/res/values-es-rUS/strings.xml
+++ b/res/values-es-rUS/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Fondo de pantalla y estilo"</string>
     <string name="theme_title" msgid="2144932106319405101">"Estilo"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Reloj person."</string>
-    <string name="clock_description" msgid="3563839327378948">"Elige un reloj"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Cambia el reloj personalizado"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Reloj"</string>
     <string name="grid_title" msgid="1688173478777254123">"Cuadr. de apps"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Aplicar"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Presiona para editar"</string>
diff --git a/res/values-es/strings.xml b/res/values-es/strings.xml
index 6aceec2..c45e390 100644
--- a/res/values-es/strings.xml
+++ b/res/values-es/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Fondo de pantalla y estilo"</string>
     <string name="theme_title" msgid="2144932106319405101">"Estilo"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Reloj personalizado"</string>
-    <string name="clock_description" msgid="3563839327378948">"Elige un reloj personalizado"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Cambiar reloj personalizado"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Reloj"</string>
     <string name="grid_title" msgid="1688173478777254123">"Cuadrícula de apps"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Aplicar"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Toca para editar"</string>
diff --git a/res/values-et/strings.xml b/res/values-et/strings.xml
index bad77e8..2a6e051 100644
--- a/res/values-et/strings.xml
+++ b/res/values-et/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Taustapilt ja stiil"</string>
     <string name="theme_title" msgid="2144932106319405101">"Stiil"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Kohandatud kell"</string>
-    <string name="clock_description" msgid="3563839327378948">"Kohandatud kell"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Kohandatud kella muutmine"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Kell"</string>
     <string name="grid_title" msgid="1688173478777254123">"Rak. ruudustik"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Rakenda"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Puudutage muutmiseks"</string>
diff --git a/res/values-eu/strings.xml b/res/values-eu/strings.xml
index b7e748c..7944b93 100644
--- a/res/values-eu/strings.xml
+++ b/res/values-eu/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Horma-papera eta estiloa"</string>
     <string name="theme_title" msgid="2144932106319405101">"Estiloa"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Esfera pertsonalizatuak"</string>
-    <string name="clock_description" msgid="3563839327378948">"Hautatu esfera pertsonalizatu bat"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Aldatu esfera pertsonalizatua"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Erlojua"</string>
     <string name="grid_title" msgid="1688173478777254123">"Aplikazioen sareta"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Aplikatu"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Sakatu editatzeko"</string>
@@ -81,7 +79,7 @@
     <string name="accessibility_custom_shape_title" msgid="7708408259374643129">"Forma pertsonalizatua"</string>
     <string name="accessibility_custom_name_title" msgid="5494460518085463262">"Estilo pertsonalizatuaren izena"</string>
     <string name="mode_title" msgid="2394873501427436055">"Gai iluna"</string>
-    <string name="mode_disabled_msg" msgid="9196245518435936512">"Aldi baterako desgaituta, bateria-aurreztailea dela eta"</string>
+    <string name="mode_disabled_msg" msgid="9196245518435936512">"Aldi baterako desgaituta, bateria-aurrezlea dela eta"</string>
     <string name="mode_changed" msgid="2243581369395418584">"Aldatu da gaia"</string>
     <string name="themed_icon_title" msgid="7312460430471956558">"Ikono gaidunak"</string>
     <string name="beta_title" msgid="8703819523760746458">"Beta"</string>
diff --git a/res/values-fa/strings.xml b/res/values-fa/strings.xml
index 1d3a43a..4a5f763 100644
--- a/res/values-fa/strings.xml
+++ b/res/values-fa/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"کاغذدیواری و سبک"</string>
     <string name="theme_title" msgid="2144932106319405101">"سبک"</string>
-    <string name="clock_title" msgid="1974314575211361352">"ساعت سفارشی"</string>
-    <string name="clock_description" msgid="3563839327378948">"انتخاب ساعت سفارشی"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"تغییر ساعت سفارشی"</string>
+    <string name="clock_title" msgid="2126046720254613991">"ساعت"</string>
     <string name="grid_title" msgid="1688173478777254123">"جدول برنامه"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"اعمال"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"برای ویرایش ضربه بزنید"</string>
diff --git a/res/values-fi/strings.xml b/res/values-fi/strings.xml
index 61047d8..37f57b8 100644
--- a/res/values-fi/strings.xml
+++ b/res/values-fi/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Taustakuva ja tyyli"</string>
     <string name="theme_title" msgid="2144932106319405101">"Tyyli"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Oma kello"</string>
-    <string name="clock_description" msgid="3563839327378948">"Valitse kello"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Muuta omaa kelloa"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Kello"</string>
     <string name="grid_title" msgid="1688173478777254123">"Ruudukko"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Käytä"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Muokkaa napauttamalla"</string>
diff --git a/res/values-fr-rCA/strings.xml b/res/values-fr-rCA/strings.xml
index 0d0d44d..c271e5c 100644
--- a/res/values-fr-rCA/strings.xml
+++ b/res/values-fr-rCA/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Fond d\'écran et style"</string>
     <string name="theme_title" msgid="2144932106319405101">"Style"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Horloge personnalisée"</string>
-    <string name="clock_description" msgid="3563839327378948">"Choisissez une horloge personnalisée"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Modifiez une horloge personnalisée"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Horloge"</string>
     <string name="grid_title" msgid="1688173478777254123">"Grille d\'applis"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Appliquer"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Toucher pour modifier"</string>
diff --git a/res/values-fr/strings.xml b/res/values-fr/strings.xml
index c87878d..05dfdfd 100644
--- a/res/values-fr/strings.xml
+++ b/res/values-fr/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Fond d\'écran et style"</string>
     <string name="theme_title" msgid="2144932106319405101">"Style"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Cadran perso."</string>
-    <string name="clock_description" msgid="3563839327378948">"Choisir cadran"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Modifier un cadran personnalisé"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Horloge"</string>
     <string name="grid_title" msgid="1688173478777254123">"Grille d\'applis"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Appliquer"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Appuyer pour modifier"</string>
@@ -86,7 +84,7 @@
     <string name="themed_icon_title" msgid="7312460430471956558">"Icônes à thème"</string>
     <string name="beta_title" msgid="8703819523760746458">"Bêta"</string>
     <string name="gird_picker_entry_content_description" msgid="9087651470212293439">"Modifier la grille d\'applis"</string>
-    <string name="wallpaper_color_tab" msgid="1447926591721403840">"Couleurs fond d\'écran"</string>
+    <string name="wallpaper_color_tab" msgid="1447926591721403840">"Couleurs du fond"</string>
     <string name="wallpaper_color_title" msgid="5687965239180986458">"Couleur du fond d\'écran"</string>
     <string name="preset_color_tab" msgid="3133391839341329314">"Couleurs de base"</string>
     <string name="color_changed" msgid="7029571720331641235">"Couleur modifiée"</string>
diff --git a/res/values-gl/strings.xml b/res/values-gl/strings.xml
index 0f9743d..5b90944 100644
--- a/res/values-gl/strings.xml
+++ b/res/values-gl/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Estilo e fondo de pantalla"</string>
     <string name="theme_title" msgid="2144932106319405101">"Estilo"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Reloxo person."</string>
-    <string name="clock_description" msgid="3563839327378948">"Elixe reloxo pers."</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Cambiar reloxo personalizado"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Reloxo"</string>
     <string name="grid_title" msgid="1688173478777254123">"Grade de apps"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Aplicar"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Toca para editar"</string>
@@ -69,7 +67,7 @@
     <string name="set_theme_wallpaper_dialog_message" msgid="2179661027350908003">"Definir fondo de pantalla do estilo"</string>
     <string name="use_style_instead_title" msgid="1578754995763917502">"Prefires utilizar <xliff:g id="ID_1">%1$s</xliff:g>?"</string>
     <string name="use_style_instead_body" msgid="3051937045807471496">"O estilo de <xliff:g id="ID_1">%1$s</xliff:g> concorda cos compoñentes que escolliches. Prefires utilizar <xliff:g id="ID_2">%1$s</xliff:g>?"</string>
-    <string name="use_style_button" msgid="1754493078383627019">"Usar <xliff:g id="ID_1">%1$s</xliff:g>"</string>
+    <string name="use_style_button" msgid="1754493078383627019">"Utilizar <xliff:g id="ID_1">%1$s</xliff:g>"</string>
     <string name="no_thanks" msgid="7286616980115687627">"Non, grazas"</string>
     <string name="clock_preview_content_description" msgid="5460561185905717460">"Vista previa do reloxo <xliff:g id="ID_1">%1$s</xliff:g>"</string>
     <string name="something_went_wrong" msgid="529840112449799117">"Ai! Produciuse un erro."</string>
diff --git a/res/values-gu/strings.xml b/res/values-gu/strings.xml
index 4f501b2..95af51f 100644
--- a/res/values-gu/strings.xml
+++ b/res/values-gu/strings.xml
@@ -17,11 +17,9 @@
 
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="app_name" msgid="1647136562008520313">"વૉલપેપર અને સ્ટાઇલ"</string>
+    <string name="app_name" msgid="1647136562008520313">"વૉલપેપર અને શૈલી"</string>
     <string name="theme_title" msgid="2144932106319405101">"શૈલી"</string>
-    <string name="clock_title" msgid="1974314575211361352">"કસ્ટમ ઘડિયાળ"</string>
-    <string name="clock_description" msgid="3563839327378948">"કસ્ટમ ઘડિયાળ ચૂંટો"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"કસ્ટમ ઘડિયાળ બદલો"</string>
+    <string name="clock_title" msgid="2126046720254613991">"ઘડિયાળ"</string>
     <string name="grid_title" msgid="1688173478777254123">"ઍપ ગ્રિડ"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"લાગુ કરો"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"ફેરફાર કરવા માટે ટૅપ કરો"</string>
diff --git a/res/values-hi/strings.xml b/res/values-hi/strings.xml
index 0b0b8b7..a207bfe 100644
--- a/res/values-hi/strings.xml
+++ b/res/values-hi/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"वॉलपेपर और स्टाइल"</string>
     <string name="theme_title" msgid="2144932106319405101">"शैली"</string>
-    <string name="clock_title" msgid="1974314575211361352">"घड़ी का आइकॉन"</string>
-    <string name="clock_description" msgid="3563839327378948">"घड़ी आइकॉन चुनें"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"पसंद के मुताबिक घड़ी का आइकॉन बदलें"</string>
+    <string name="clock_title" msgid="2126046720254613991">"घड़ी"</string>
     <string name="grid_title" msgid="1688173478777254123">"ऐप्लिकेशन ग्रिड"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"लागू करें"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"बदलाव करने के लिए टैप करें"</string>
diff --git a/res/values-hr/strings.xml b/res/values-hr/strings.xml
index bb33da1..b603fa6 100644
--- a/res/values-hr/strings.xml
+++ b/res/values-hr/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Pozadina i stil"</string>
     <string name="theme_title" msgid="2144932106319405101">"Stil"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Prilagođeni sat"</string>
-    <string name="clock_description" msgid="3563839327378948">"Odaberite prilagođeni sat"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Promijenite prilagođeni sat"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Sat"</string>
     <string name="grid_title" msgid="1688173478777254123">"Rešetka aplik."</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Primijeni"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Dodirnite da biste uredili"</string>
diff --git a/res/values-hu/strings.xml b/res/values-hu/strings.xml
index b814c0c..620d36c 100644
--- a/res/values-hu/strings.xml
+++ b/res/values-hu/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Háttérkép és stílus"</string>
     <string name="theme_title" msgid="2144932106319405101">"Stílus"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Egyedi óra"</string>
-    <string name="clock_description" msgid="3563839327378948">"Egyedi óra választása"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Egyedi óra módosítása"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Óra"</string>
     <string name="grid_title" msgid="1688173478777254123">"Alkalmazásrács"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Alkalmaz"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Koppintson a szerkesztéshez"</string>
diff --git a/res/values-hy/strings.xml b/res/values-hy/strings.xml
index b3d5829..7c7d059 100644
--- a/res/values-hy/strings.xml
+++ b/res/values-hy/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Պաստառ և ոճ"</string>
     <string name="theme_title" msgid="2144932106319405101">"Ոճ"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Հատուկ թվատախտակ"</string>
-    <string name="clock_description" msgid="3563839327378948">"Ընտրեք թվատախտակ"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Փոխեք հատուկ թվատախտակը"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Ժամացույց"</string>
     <string name="grid_title" msgid="1688173478777254123">"Հավելվածների ցանց"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Կիրառել"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Հպեք՝ փոփոխելու համար"</string>
diff --git a/res/values-in/strings.xml b/res/values-in/strings.xml
index ffbfdbd..7e48536 100644
--- a/res/values-in/strings.xml
+++ b/res/values-in/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Wallpaper &amp; gaya"</string>
     <string name="theme_title" msgid="2144932106319405101">"Gaya"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Jam Kustom"</string>
-    <string name="clock_description" msgid="3563839327378948">"Pilih jam kustom"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Ubah jam kustom"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Jam"</string>
     <string name="grid_title" msgid="1688173478777254123">"Petak aplikasi"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Terapkan"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Ketuk untuk mengedit"</string>
@@ -50,7 +48,7 @@
     <string name="applied_theme_msg" msgid="3749018706366796244">"Gaya berhasil disetel"</string>
     <string name="applied_clock_msg" msgid="1303338016701443767">"Jam berhasil disetel"</string>
     <string name="applied_grid_msg" msgid="3250499654436933034">"Petak berhasil disetel"</string>
-    <string name="apply_theme_error_msg" msgid="791364062636538317">"Terjadi error saat menerapkan gaya"</string>
+    <string name="apply_theme_error_msg" msgid="791364062636538317">"Terjadi masalah saat menerapkan gaya"</string>
     <string name="custom_theme_next" msgid="6235420097213197301">"Berikutnya"</string>
     <string name="custom_theme_previous" msgid="4941132112640503022">"Sebelumnya"</string>
     <string name="custom_theme" msgid="1618351922263478163">"Kustom"</string>
@@ -72,7 +70,7 @@
     <string name="use_style_button" msgid="1754493078383627019">"Gunakan <xliff:g id="ID_1">%1$s</xliff:g>"</string>
     <string name="no_thanks" msgid="7286616980115687627">"Lain kali"</string>
     <string name="clock_preview_content_description" msgid="5460561185905717460">"Pratinjau jam <xliff:g id="ID_1">%1$s</xliff:g>"</string>
-    <string name="something_went_wrong" msgid="529840112449799117">"Maaf, terjadi error."</string>
+    <string name="something_went_wrong" msgid="529840112449799117">"Ups! Ada yang tidak beres."</string>
     <string name="theme_preview_icons_section_title" msgid="7064768910744000643">"Warna/Ikon"</string>
     <string name="style_info_description" msgid="2612473574431003251">"Pratinjau font, ikon, bentuk aplikasi, dan warna"</string>
     <string name="accessibility_custom_font_title" msgid="966867359157303705">"Font khusus"</string>
diff --git a/res/values-is/strings.xml b/res/values-is/strings.xml
index 96f78b2..9312a5c 100644
--- a/res/values-is/strings.xml
+++ b/res/values-is/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Veggfóður og stíll"</string>
     <string name="theme_title" msgid="2144932106319405101">"Stíll"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Sérsniðin klukka"</string>
-    <string name="clock_description" msgid="3563839327378948">"Veldu sérsniðna klukku"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Breyta sérsniðinni klukku"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Klukka"</string>
     <string name="grid_title" msgid="1688173478777254123">"Forritatafla"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Nota"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Ýttu til að breyta"</string>
diff --git a/res/values-it/strings.xml b/res/values-it/strings.xml
index 1e24a3f..08df999 100644
--- a/res/values-it/strings.xml
+++ b/res/values-it/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Sfondo e stile"</string>
     <string name="theme_title" msgid="2144932106319405101">"Stile"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Orologio personalizzato"</string>
-    <string name="clock_description" msgid="3563839327378948">"Scegli un orologio personalizzato"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Modifica un orologio personalizzato"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Orologio"</string>
     <string name="grid_title" msgid="1688173478777254123">"Griglia di app"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Applica"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Tocca per modificare"</string>
diff --git a/res/values-iw/strings.xml b/res/values-iw/strings.xml
index 4f3556f..5d9e2d9 100644
--- a/res/values-iw/strings.xml
+++ b/res/values-iw/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"טפט וסגנון"</string>
     <string name="theme_title" msgid="2144932106319405101">"סגנון"</string>
-    <string name="clock_title" msgid="1974314575211361352">"שעון מותאם אישית"</string>
-    <string name="clock_description" msgid="3563839327378948">"בחירת שעון מותאם אישית"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"שינוי שעון מותאם אישית"</string>
+    <string name="clock_title" msgid="2126046720254613991">"שעון"</string>
     <string name="grid_title" msgid="1688173478777254123">"תצוגת האפליקציות"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"אישור"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"יש להקיש כדי לערוך"</string>
diff --git a/res/values-ja/strings.xml b/res/values-ja/strings.xml
index 7eafb66..f6a20d3 100644
--- a/res/values-ja/strings.xml
+++ b/res/values-ja/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"壁紙とスタイル"</string>
     <string name="theme_title" msgid="2144932106319405101">"スタイル"</string>
-    <string name="clock_title" msgid="1974314575211361352">"カスタム文字盤"</string>
-    <string name="clock_description" msgid="3563839327378948">"文字盤の選択"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"文字盤の変更"</string>
+    <string name="clock_title" msgid="2126046720254613991">"時計"</string>
     <string name="grid_title" msgid="1688173478777254123">"アプリグリッド"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"適用"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"タップして編集"</string>
diff --git a/res/values-ka/strings.xml b/res/values-ka/strings.xml
index a6b91ec..7fb2f96 100644
--- a/res/values-ka/strings.xml
+++ b/res/values-ka/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"ფონი და სტილი"</string>
     <string name="theme_title" msgid="2144932106319405101">"სტილი"</string>
-    <string name="clock_title" msgid="1974314575211361352">"მორგებული საათი"</string>
-    <string name="clock_description" msgid="3563839327378948">"აირჩიეთ მორგებული საათი"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"შეცვალეთ მორგებული საათი"</string>
+    <string name="clock_title" msgid="2126046720254613991">"საათი"</string>
     <string name="grid_title" msgid="1688173478777254123">"აპების ბადე"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"მისადაგება"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"შეეხეთ რედაქტირებისთვის"</string>
diff --git a/res/values-kk/strings.xml b/res/values-kk/strings.xml
index abee0ba..c62d6a0 100644
--- a/res/values-kk/strings.xml
+++ b/res/values-kk/strings.xml
@@ -19,19 +19,17 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Тұсқағаз және стиль"</string>
     <string name="theme_title" msgid="2144932106319405101">"Стиль"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Арнаулы сағат"</string>
-    <string name="clock_description" msgid="3563839327378948">"Арнаулы сағатты таңдау"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Арнаулы сағатты өзгерту"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Cағат"</string>
     <string name="grid_title" msgid="1688173478777254123">"Қолданба торы"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Қолдану"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Өзгерту үшін түртіңіз"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Қазіргі тұсқағазды қалдыру"</string>
-    <string name="theme_preview_card_content_description" msgid="5989222908619535533">"Стильді алдын ала көру"</string>
-    <string name="grid_preview_card_content_description" msgid="8449383777584714842">"Торды алдын ала көру"</string>
-    <string name="font_preview_content_description" msgid="128230439293337891">"Қаріпті алдын ала көру"</string>
-    <string name="icon_preview_content_description" msgid="7761101284351952890">"Белгішені алдын ала көру"</string>
-    <string name="color_preview_content_description" msgid="4879120462082058124">"Түсті алдын ала көру"</string>
-    <string name="shape_preview_content_description" msgid="6479487796176550432">"Пішінді алдын ала көру"</string>
+    <string name="theme_preview_card_content_description" msgid="5989222908619535533">"Стильді алдын ала қарау"</string>
+    <string name="grid_preview_card_content_description" msgid="8449383777584714842">"Торды алдын ала қарау"</string>
+    <string name="font_preview_content_description" msgid="128230439293337891">"Қаріпті алдын ала қарау"</string>
+    <string name="icon_preview_content_description" msgid="7761101284351952890">"Белгішені алдын ала қарау"</string>
+    <string name="color_preview_content_description" msgid="4879120462082058124">"Түсті алдын ала қарау"</string>
+    <string name="shape_preview_content_description" msgid="6479487796176550432">"Пішінді алдын ала қарау"</string>
     <string name="option_applied_description" msgid="5022305212078053534">"<xliff:g id="ID_1">%1$s</xliff:g>, қазір қосулы"</string>
     <string name="option_applied_previewed_description" msgid="5269654286638446858">"<xliff:g id="ID_1">%1$s</xliff:g>, қазір қолданылды және алдын ала қаралды"</string>
     <string name="option_previewed_description" msgid="3467217598865047661">"<xliff:g id="ID_1">%1$s</xliff:g>, қазір алдын ала қаралды"</string>
@@ -71,10 +69,10 @@
     <string name="use_style_instead_body" msgid="3051937045807471496">"Таңдаған компоненттеріңіз <xliff:g id="ID_1">%1$s</xliff:g> стиліне сәйкес келеді. Орнына <xliff:g id="ID_2">%1$s</xliff:g> стилін пайдаланғыңыз келе ме?"</string>
     <string name="use_style_button" msgid="1754493078383627019">"<xliff:g id="ID_1">%1$s</xliff:g> таңдалсын"</string>
     <string name="no_thanks" msgid="7286616980115687627">"Жоқ, рақмет"</string>
-    <string name="clock_preview_content_description" msgid="5460561185905717460">"<xliff:g id="ID_1">%1$s</xliff:g> сағатын алдын ала көру"</string>
+    <string name="clock_preview_content_description" msgid="5460561185905717460">"<xliff:g id="ID_1">%1$s</xliff:g> сағатын алдын ала қарау"</string>
     <string name="something_went_wrong" msgid="529840112449799117">"Қап! Бірдеңе дұрыс болмады."</string>
     <string name="theme_preview_icons_section_title" msgid="7064768910744000643">"Түс/Белгішелер"</string>
-    <string name="style_info_description" msgid="2612473574431003251">"Қаріпті, белгішелерді, қолданба пішінін алдын ала көру"</string>
+    <string name="style_info_description" msgid="2612473574431003251">"Қаріпті, белгішелерді, қолданба пішінін алдын ала қарау"</string>
     <string name="accessibility_custom_font_title" msgid="966867359157303705">"Арнаулы қаріп"</string>
     <string name="accessibility_custom_icon_title" msgid="5753297905849062296">"Арнаулы белгіше"</string>
     <string name="accessibility_custom_color_title" msgid="4124246598886320663">"Арнаулы түс"</string>
diff --git a/res/values-km/strings.xml b/res/values-km/strings.xml
index eb1dca6..02080a7 100644
--- a/res/values-km/strings.xml
+++ b/res/values-km/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"ផ្ទាំងរូបភាព និងរចនាប័ទ្ម"</string>
     <string name="theme_title" msgid="2144932106319405101">"រចនាប័ទ្ម"</string>
-    <string name="clock_title" msgid="1974314575211361352">"នាឡិកាផ្ទាល់ខ្លួន"</string>
-    <string name="clock_description" msgid="3563839327378948">"ជ្រើសរើសនាឡិកាផ្ទាល់ខ្លួន"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"ប្ដូរនាឡិកា​ផ្ទាល់ខ្លួន"</string>
+    <string name="clock_title" msgid="2126046720254613991">"នាឡិកា"</string>
     <string name="grid_title" msgid="1688173478777254123">"ក្រឡា​កម្មវិធី"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"ប្រើ"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"ចុច ដើម្បី​កែ"</string>
@@ -83,7 +81,7 @@
     <string name="mode_title" msgid="2394873501427436055">"​រចនាប័ទ្ម​ងងឹត"</string>
     <string name="mode_disabled_msg" msgid="9196245518435936512">"បានបិទ​ជា​បណ្តោះអាសន្ន ដោយសារ​មុខងារ​សន្សំ​ថ្ម"</string>
     <string name="mode_changed" msgid="2243581369395418584">"បាន​ផ្លាស់ប្ដូរ​រចនាប័ទ្ម"</string>
-    <string name="themed_icon_title" msgid="7312460430471956558">"រូបតំណាងប្ដូរតាមទម្រង់រចនា"</string>
+    <string name="themed_icon_title" msgid="7312460430471956558">"រូបតំណាងប្ដូររចនាប័ទ្ម"</string>
     <string name="beta_title" msgid="8703819523760746458">"បេតា"</string>
     <string name="gird_picker_entry_content_description" msgid="9087651470212293439">"ប្ដូរ​ក្រឡា​កម្មវិធី"</string>
     <string name="wallpaper_color_tab" msgid="1447926591721403840">"ពណ៌ផ្ទាំងរូបភាព"</string>
diff --git a/res/values-kn/strings.xml b/res/values-kn/strings.xml
index f1b6efe..95d8df3 100644
--- a/res/values-kn/strings.xml
+++ b/res/values-kn/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"ವಾಲ್‌ಪೇಪರ್ ಮತ್ತು ಶೈಲಿ"</string>
     <string name="theme_title" msgid="2144932106319405101">"ಶೈಲಿ"</string>
-    <string name="clock_title" msgid="1974314575211361352">"ಕಸ್ಟಮ್ ಗಡಿಯಾರ"</string>
-    <string name="clock_description" msgid="3563839327378948">"ಕಸ್ಟಮ್ ವಾಚ್ ಪಿಕ್"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"ಕಸ್ಟಮ್ ಗಡಿಯಾರ ಬದಲಿಸಿ"</string>
+    <string name="clock_title" msgid="2126046720254613991">"ಗಡಿಯಾರ"</string>
     <string name="grid_title" msgid="1688173478777254123">"ಆ್ಯಪ್ ಗ್ರಿಡ್"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"ಅನ್ವಯಿಸಿ"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"ಎಡಿಟ್ ಮಾಡಲು ಟ್ಯಾಪ್ ಮಾಡಿ"</string>
diff --git a/res/values-ko/strings.xml b/res/values-ko/strings.xml
index ef1e573..25e7d43 100644
--- a/res/values-ko/strings.xml
+++ b/res/values-ko/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"배경화면 및 스타일"</string>
     <string name="theme_title" msgid="2144932106319405101">"스타일"</string>
-    <string name="clock_title" msgid="1974314575211361352">"맞춤 시계"</string>
-    <string name="clock_description" msgid="3563839327378948">"맞춤 시계 선택"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"맞춤 시계 변경"</string>
+    <string name="clock_title" msgid="2126046720254613991">"시계"</string>
     <string name="grid_title" msgid="1688173478777254123">"앱 그리드"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"적용"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"탭하여 수정"</string>
diff --git a/res/values-ky/strings.xml b/res/values-ky/strings.xml
index e292d1e..f7b60ef 100644
--- a/res/values-ky/strings.xml
+++ b/res/values-ky/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Тушкагаз жана стиль"</string>
     <string name="theme_title" msgid="2144932106319405101">"Стиль"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Жеке саат"</string>
-    <string name="clock_description" msgid="3563839327378948">"Жеке саатты тандоо"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Жеке саатты өзгөртүү"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Саат"</string>
     <string name="grid_title" msgid="1688173478777254123">"Колдонмонун торчосу"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Колдонуу"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Өзгөртүү үчүн таптап коюңуз"</string>
diff --git a/res/values-lo/strings.xml b/res/values-lo/strings.xml
index c70c1e7..8fe51ba 100644
--- a/res/values-lo/strings.xml
+++ b/res/values-lo/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"ຮູບພື້ນຫຼັງ ແລະ ຮູບແບບ"</string>
     <string name="theme_title" msgid="2144932106319405101">"ຮູບແບບ"</string>
-    <string name="clock_title" msgid="1974314575211361352">"ໂມງທີ່ກຳນົດເອງ"</string>
-    <string name="clock_description" msgid="3563839327378948">"ເລືອກໂມງກຳນົດເອງ"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"ປ່ຽນໂມງກຳນົດເອງ"</string>
+    <string name="clock_title" msgid="2126046720254613991">"ໂມງ"</string>
     <string name="grid_title" msgid="1688173478777254123">"ຕາຕະລາງແອັບ"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"ນຳໃຊ້"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"ແຕະເພື່ອແກ້ໄຂ"</string>
diff --git a/res/values-lt/strings.xml b/res/values-lt/strings.xml
index 2075eda..02b289b 100644
--- a/res/values-lt/strings.xml
+++ b/res/values-lt/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Ekrano fonas ir stilius"</string>
     <string name="theme_title" msgid="2144932106319405101">"Stilius"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Tink. laikrodis"</string>
-    <string name="clock_description" msgid="3563839327378948">"Pasir. tink. laikr."</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Keiskite tinkintą laikrodį"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Laikrodis"</string>
     <string name="grid_title" msgid="1688173478777254123">"Pr. tinklelis"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Taikyti"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Palieskite ir redaguokite"</string>
diff --git a/res/values-lv/strings.xml b/res/values-lv/strings.xml
index 2c89c6d..f8fb310 100644
--- a/res/values-lv/strings.xml
+++ b/res/values-lv/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Fona tapete un stils"</string>
     <string name="theme_title" msgid="2144932106319405101">"Stils"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Pielāgots ekrāns"</string>
-    <string name="clock_description" msgid="3563839327378948">"Pielāgota ekrāna izvēle"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Mainiet pielāgotu pulksteņa ekrānu."</string>
+    <string name="clock_title" msgid="2126046720254613991">"Pulkstenis"</string>
     <string name="grid_title" msgid="1688173478777254123">"Lietotņu režģis"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Lietot"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Pieskarieties, lai rediģētu"</string>
diff --git a/res/values-mk/strings.xml b/res/values-mk/strings.xml
index b81d472..197058c 100644
--- a/res/values-mk/strings.xml
+++ b/res/values-mk/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Тапет и стил"</string>
     <string name="theme_title" msgid="2144932106319405101">"Стил"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Приспособен часовник"</string>
-    <string name="clock_description" msgid="3563839327378948">"Изберете приспособен часовник"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Променете го приспособениот часовник"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Часовник"</string>
     <string name="grid_title" msgid="1688173478777254123">"Мрежа"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Примени"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Допрете за да измените"</string>
diff --git a/res/values-ml/strings.xml b/res/values-ml/strings.xml
index 704dc54..91ae2dc 100644
--- a/res/values-ml/strings.xml
+++ b/res/values-ml/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"വാൾപേപ്പറും സ്‌റ്റൈലും"</string>
     <string name="theme_title" msgid="2144932106319405101">"സ്‌റ്റൈൽ"</string>
-    <string name="clock_title" msgid="1974314575211361352">"കസ്റ്റം ക്ലോക്ക്"</string>
-    <string name="clock_description" msgid="3563839327378948">"കസ്റ്റം ക്ലോക്ക് തിരഞ്ഞെടുക്കൂ"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"ഇഷ്‌ടാനുസൃത  ക്ലോക്ക് മാറ്റൂ"</string>
+    <string name="clock_title" msgid="2126046720254613991">"ക്ലോക്ക്"</string>
     <string name="grid_title" msgid="1688173478777254123">"ആപ്പ് ഗ്രിഡ്"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"പ്രയോഗിക്കുക"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"എഡിറ്റ് ചെയ്യാൻ ടാപ്പ് ചെയ്യുക"</string>
diff --git a/res/values-mn/strings.xml b/res/values-mn/strings.xml
index d7c8034..6fc45b5 100644
--- a/res/values-mn/strings.xml
+++ b/res/values-mn/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Дэлгэцийн зураг, загвар"</string>
     <string name="theme_title" msgid="2144932106319405101">"Загвар"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Захиалгат цаг"</string>
-    <string name="clock_description" msgid="3563839327378948">"Захиалгат цаг сонгох"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Захиалгат цагийг өөрчлөх"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Цаг"</string>
     <string name="grid_title" msgid="1688173478777254123">"Аппын хүснэгт"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Ашиглах"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Засахын тулд товшино уу"</string>
diff --git a/res/values-mr/strings.xml b/res/values-mr/strings.xml
index f889992..0eba26e 100644
--- a/res/values-mr/strings.xml
+++ b/res/values-mr/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"वॉलपेपर आणि शैली"</string>
     <string name="theme_title" msgid="2144932106319405101">"शैली"</string>
-    <string name="clock_title" msgid="1974314575211361352">"कस्टम क्लॉक"</string>
-    <string name="clock_description" msgid="3563839327378948">"कस्टम क्लॉक निवडा"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"कस्टम क्लॉक बदला"</string>
+    <string name="clock_title" msgid="2126046720254613991">"घड्याळ"</string>
     <string name="grid_title" msgid="1688173478777254123">"ॲप ग्रिड"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"लागू करा"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"संपादित करण्‍यासाठी टॅप करा"</string>
diff --git a/res/values-ms/strings.xml b/res/values-ms/strings.xml
index 54e1b8b..a241339 100644
--- a/res/values-ms/strings.xml
+++ b/res/values-ms/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Kertas dinding &amp; gaya"</string>
     <string name="theme_title" msgid="2144932106319405101">"Gaya"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Jam Tersuai"</string>
-    <string name="clock_description" msgid="3563839327378948">"Pilih jam tersuai"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Tukar jam tersuai"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Jam"</string>
     <string name="grid_title" msgid="1688173478777254123">"Grid apl"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Gunakan"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Ketik untuk edit"</string>
diff --git a/res/values-my/strings.xml b/res/values-my/strings.xml
index a39ffe9..1f63a7a 100644
--- a/res/values-my/strings.xml
+++ b/res/values-my/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"နောက်ခံနှင့် ပုံစံ"</string>
     <string name="theme_title" msgid="2144932106319405101">"ပုံစံ"</string>
-    <string name="clock_title" msgid="1974314575211361352">"စိတ်ကြိုက်နာရီ"</string>
-    <string name="clock_description" msgid="3563839327378948">"စိတ်ကြိုက်နာရီရွေးပါ"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"စိတ်ကြိုက်နာရီ ပြောင်းနိုင်သည်"</string>
+    <string name="clock_title" msgid="2126046720254613991">"နာရီ"</string>
     <string name="grid_title" msgid="1688173478777254123">"အက်ပ်ဇယား"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"အသုံးပြုရန်"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"တည်းဖြတ်ရန် တို့ပါ"</string>
@@ -80,15 +78,15 @@
     <string name="accessibility_custom_color_title" msgid="4124246598886320663">"စိတ်ကြိုက်အရောင်"</string>
     <string name="accessibility_custom_shape_title" msgid="7708408259374643129">"စိတ်ကြိုက်ပုံသဏ္ဌာန်"</string>
     <string name="accessibility_custom_name_title" msgid="5494460518085463262">"စိတ်ကြိုက်ပုံစံအမည်"</string>
-    <string name="mode_title" msgid="2394873501427436055">"အမှောင်နောက်ခံ"</string>
+    <string name="mode_title" msgid="2394873501427436055">"မှောင်သည့် အပြင်အဆင်"</string>
     <string name="mode_disabled_msg" msgid="9196245518435936512">"‘ဘက်ထရီ အားထိန်း’ ကြောင့် ယာယီပိတ်ထားသည်"</string>
     <string name="mode_changed" msgid="2243581369395418584">"အပြင်အဆင် ပြောင်းလိုက်ပါပြီ"</string>
     <string name="themed_icon_title" msgid="7312460430471956558">"အပြင်အဆင်သုံး သင်္ကေတများ"</string>
-    <string name="beta_title" msgid="8703819523760746458">"စမ်းသပ်"</string>
+    <string name="beta_title" msgid="8703819523760746458">"စမ်းသပ်ဆော့ဖ်ဝဲ"</string>
     <string name="gird_picker_entry_content_description" msgid="9087651470212293439">"အက်ပ်ဇယား ပြောင်းရန်"</string>
     <string name="wallpaper_color_tab" msgid="1447926591721403840">"နောက်ခံအရောင်များ"</string>
     <string name="wallpaper_color_title" msgid="5687965239180986458">"နောက်ခံအရောင်"</string>
-    <string name="preset_color_tab" msgid="3133391839341329314">"အခြေခံအရောင်များ"</string>
+    <string name="preset_color_tab" msgid="3133391839341329314">"မူရင်းအရောင်များ"</string>
     <string name="color_changed" msgid="7029571720331641235">"အရောင် ပြောင်းလိုက်ပါပြီ"</string>
     <string name="adaptive_color_title" msgid="1336508599235896205">"ပြောင်းနိုင်သော"</string>
 </resources>
diff --git a/res/values-nb/strings.xml b/res/values-nb/strings.xml
index c5baa00..a82f28b 100644
--- a/res/values-nb/strings.xml
+++ b/res/values-nb/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Bakgrunn og stil"</string>
     <string name="theme_title" msgid="2144932106319405101">"Stil"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Tilpasset klokke"</string>
-    <string name="clock_description" msgid="3563839327378948">"Velg en tilpasset klokke"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Endre en tilpasset klokke"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Klokke"</string>
     <string name="grid_title" msgid="1688173478777254123">"Apprutenett"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Bruk"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Trykk for å endre"</string>
diff --git a/res/values-ne/strings.xml b/res/values-ne/strings.xml
index b616454..a29a975 100644
--- a/res/values-ne/strings.xml
+++ b/res/values-ne/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"वालपेपर तथा शैली"</string>
     <string name="theme_title" msgid="2144932106319405101">"शैली"</string>
-    <string name="clock_title" msgid="1974314575211361352">"कस्टम घडी"</string>
-    <string name="clock_description" msgid="3563839327378948">"कस्टम घडी छान्नु…"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"कुनै कस्टम घडी परिवर्तन गर्नुहोस्"</string>
+    <string name="clock_title" msgid="2126046720254613991">"घडी"</string>
     <string name="grid_title" msgid="1688173478777254123">"एप ग्रिड"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"लागू गर्नुहोस्"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"सम्पादन गर्न ट्याप गर्नुहोस्"</string>
diff --git a/res/values-nl/strings.xml b/res/values-nl/strings.xml
index 58d73e4..6210372 100644
--- a/res/values-nl/strings.xml
+++ b/res/values-nl/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Achtergrond en stijl"</string>
     <string name="theme_title" msgid="2144932106319405101">"Stijl"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Aangepaste klok"</string>
-    <string name="clock_description" msgid="3563839327378948">"Klok kiezen"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Aangepaste klok wijzigen"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Klok"</string>
     <string name="grid_title" msgid="1688173478777254123">"App-raster"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Toepassen"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Tik om te bewerken"</string>
diff --git a/res/values-or/strings.xml b/res/values-or/strings.xml
index bc27705..8df3d48 100644
--- a/res/values-or/strings.xml
+++ b/res/values-or/strings.xml
@@ -19,12 +19,10 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"ୱାଲପେପର୍ ଏବଂ ଷ୍ଟାଇଲ୍"</string>
     <string name="theme_title" msgid="2144932106319405101">"ଷ୍ଟାଇଲ୍"</string>
-    <string name="clock_title" msgid="1974314575211361352">"କଷ୍ଟମ ଘଣ୍ଟା"</string>
-    <string name="clock_description" msgid="3563839327378948">"କଷ୍ଟମ ଘଣ୍ଟା ବାଛ"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"ଏକ କଷ୍ଟମ ଘଣ୍ଟାକୁ ପରିବର୍ତ୍ତନ କରନ୍ତୁ"</string>
+    <string name="clock_title" msgid="2126046720254613991">"ଘଣ୍ଟା"</string>
     <string name="grid_title" msgid="1688173478777254123">"ଆପ୍ ଗ୍ରିଡ୍"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"ପ୍ରୟୋଗ କରନ୍ତୁ"</string>
-    <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"ଏଡିଟ କରିବା ପାଇଁ ଟାପ କରନ୍ତୁ"</string>
+    <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"ଏଡିଟ୍ କରିବା ପାଇଁ ଟାପ୍ କରନ୍ତୁ"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"ବର୍ତ୍ତମାନର ୱାଲ୍‌ପେପର୍‌କୁ ରଖନ୍ତୁ"</string>
     <string name="theme_preview_card_content_description" msgid="5989222908619535533">"ଷ୍ଟାଇଲ୍ ପ୍ରିଭ୍ୟୁ"</string>
     <string name="grid_preview_card_content_description" msgid="8449383777584714842">"ଗ୍ରିଡ୍ ପ୍ରିଭ୍ୟୁ"</string>
@@ -65,7 +63,7 @@
     <string name="icon_component_label" msgid="2625784884001407944">"ଆଇକନ୍ <xliff:g id="ID_1">%1$d</xliff:g>"</string>
     <string name="delete_custom_theme_confirmation" msgid="4452137183628769394">"କଷ୍ଟମ୍‌ ଶୈଳୀ ଡିଲିଟ୍ କରିବେ?"</string>
     <string name="delete_custom_theme_button" msgid="5102462988130208824">"ଡିଲିଟ୍‍ କରନ୍ତୁ"</string>
-    <string name="cancel" msgid="4651030493668562067">"ବାତିଲ କରନ୍ତୁ"</string>
+    <string name="cancel" msgid="4651030493668562067">"ବାତିଲ୍ କରନ୍ତୁ"</string>
     <string name="set_theme_wallpaper_dialog_message" msgid="2179661027350908003">"ଶୈଳୀ ଯୁକ୍ତ ୱାଲ୍‌ପେପର୍‌କୁ ସେଟ୍ କରନ୍ତୁ"</string>
     <string name="use_style_instead_title" msgid="1578754995763917502">"ଏହା ପରିବର୍ତ୍ତେ <xliff:g id="ID_1">%1$s</xliff:g> ବ୍ୟବହାର କରିବେ?"</string>
     <string name="use_style_instead_body" msgid="3051937045807471496">"ଆପଣ ବଛିଥିବା ଉପାଦାନଗୁଡ଼ିକ <xliff:g id="ID_1">%1$s</xliff:g> ଶୈଳୀ ସହ ମେଳ ହେଉଛି। ଏହା ପରିବର୍ତ୍ତେ ଆପଣ <xliff:g id="ID_2">%1$s</xliff:g>କୁ ବ୍ୟବହାର କରିବାକୁ ଚାହୁଁଛନ୍ତି କି?"</string>
@@ -88,7 +86,7 @@
     <string name="gird_picker_entry_content_description" msgid="9087651470212293439">"ଆପ୍ ଗ୍ରିଡ୍ ପରିବର୍ତ୍ତନ କରନ୍ତୁ"</string>
     <string name="wallpaper_color_tab" msgid="1447926591721403840">"ୱାଲପେପର ରଙ୍ଗଗୁଡ଼ିକ"</string>
     <string name="wallpaper_color_title" msgid="5687965239180986458">"ୱାଲପେପର ରଙ୍ଗ"</string>
-    <string name="preset_color_tab" msgid="3133391839341329314">"ମୌଳିକ ରଙ୍ଗଗୁଡ଼ିକ"</string>
+    <string name="preset_color_tab" msgid="3133391839341329314">"ବେସିକ ରଙ୍ଗଗୁଡ଼ିକ"</string>
     <string name="color_changed" msgid="7029571720331641235">"ରଙ୍ଗ ପରିବର୍ତ୍ତନ କରାଯାଇଛି"</string>
     <string name="adaptive_color_title" msgid="1336508599235896205">"ଡାଇନାମିକ"</string>
 </resources>
diff --git a/res/values-pa/strings.xml b/res/values-pa/strings.xml
index e7168d7..1d9d119 100644
--- a/res/values-pa/strings.xml
+++ b/res/values-pa/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"ਵਾਲਪੇਪਰ ਅਤੇ ਸਟਾਈਲ"</string>
     <string name="theme_title" msgid="2144932106319405101">"ਸ਼ੈਲੀ"</string>
-    <string name="clock_title" msgid="1974314575211361352">"ਵਿਉਂਤੀ ਘੜੀ"</string>
-    <string name="clock_description" msgid="3563839327378948">"ਵਿਉਂਤੀ ਘੜੀ ਚੁਣੋ"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"ਵਿਉਂਤੀ ਘੜੀ ਬਦਲੋ"</string>
+    <string name="clock_title" msgid="2126046720254613991">"ਘੜੀ"</string>
     <string name="grid_title" msgid="1688173478777254123">"ਐਪ ਗ੍ਰਿਡ"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"ਲਾਗੂ ਕਰੋ"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"ਸੰਪਾਦਨ ਕਰਨ ਲਈ ਟੈਪ ਕਰੋ"</string>
diff --git a/res/values-pl/strings.xml b/res/values-pl/strings.xml
index fa7a7ba..b3140dc 100644
--- a/res/values-pl/strings.xml
+++ b/res/values-pl/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Tapeta i styl"</string>
     <string name="theme_title" msgid="2144932106319405101">"Styl"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Własny zegar"</string>
-    <string name="clock_description" msgid="3563839327378948">"Wybierz własny zegar"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Zmień własny zegar"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Zegar"</string>
     <string name="grid_title" msgid="1688173478777254123">"Siatka aplikacji"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Zastosuj"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Kliknij, by edytować"</string>
diff --git a/res/values-pt-rPT/strings.xml b/res/values-pt-rPT/strings.xml
index ee1d738..a9a4fe3 100644
--- a/res/values-pt-rPT/strings.xml
+++ b/res/values-pt-rPT/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Imagem de fundo e estilo"</string>
     <string name="theme_title" msgid="2144932106319405101">"Estilo"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Relógio person."</string>
-    <string name="clock_description" msgid="3563839327378948">"Escolha rel. pers."</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Altere um relógio personalizado"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Relógio"</string>
     <string name="grid_title" msgid="1688173478777254123">"Grelha de apps"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Aplicar"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Toque para editar"</string>
diff --git a/res/values-pt/strings.xml b/res/values-pt/strings.xml
index cd09d6a..c858265 100644
--- a/res/values-pt/strings.xml
+++ b/res/values-pt/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Plano de fundo e estilo"</string>
     <string name="theme_title" msgid="2144932106319405101">"Estilo"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Relógio personalizado"</string>
-    <string name="clock_description" msgid="3563839327378948">"Escolha um relógio personalizado"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Edite um relógio personalizado"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Relógio"</string>
     <string name="grid_title" msgid="1688173478777254123">"Grade de apps"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Aplicar"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Toque para editar"</string>
diff --git a/res/values-ro/strings.xml b/res/values-ro/strings.xml
index 1f5aa49..7389836 100644
--- a/res/values-ro/strings.xml
+++ b/res/values-ro/strings.xml
@@ -19,13 +19,11 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Imagine de fundal și stil"</string>
     <string name="theme_title" msgid="2144932106319405101">"Stil"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Ecran personalizat"</string>
-    <string name="clock_description" msgid="3563839327378948">"Alege un ecran personalizat"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Modifică un ecran personalizat"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Ceas"</string>
     <string name="grid_title" msgid="1688173478777254123">"Grilă aplicații"</string>
-    <string name="apply_theme_btn" msgid="6293081192321303991">"Aplică"</string>
-    <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Atinge pentru a modifica"</string>
-    <string name="keep_my_wallpaper" msgid="8012385376769568517">"Păstrează imaginea de fundal actuală"</string>
+    <string name="apply_theme_btn" msgid="6293081192321303991">"Aplicați"</string>
+    <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Atingeți pentru a modifica"</string>
+    <string name="keep_my_wallpaper" msgid="8012385376769568517">"Păstrați imaginea de fundal actuală"</string>
     <string name="theme_preview_card_content_description" msgid="5989222908619535533">"Previzualizarea stilului"</string>
     <string name="grid_preview_card_content_description" msgid="8449383777584714842">"Previzualizarea grilei"</string>
     <string name="font_preview_content_description" msgid="128230439293337891">"Previzualizarea fontului"</string>
@@ -35,7 +33,7 @@
     <string name="option_applied_description" msgid="5022305212078053534">"S-a aplicat <xliff:g id="ID_1">%1$s</xliff:g> acum"</string>
     <string name="option_applied_previewed_description" msgid="5269654286638446858">"<xliff:g id="ID_1">%1$s</xliff:g>, aplicată și previzualizată acum"</string>
     <string name="option_previewed_description" msgid="3467217598865047661">"<xliff:g id="ID_1">%1$s</xliff:g>, previzualizată acum"</string>
-    <string name="option_change_applied_previewed_description" msgid="9197311327728570816">"<xliff:g id="ID_1">%1$s</xliff:g>, modifică opțiunea selectată și previzualizată"</string>
+    <string name="option_change_applied_previewed_description" msgid="9197311327728570816">"<xliff:g id="ID_1">%1$s</xliff:g>, modificați opțiunea selectată și previzualizată"</string>
     <string name="theme_description" msgid="3697012391785254635">"Font: <xliff:g id="ID_1">%1$s</xliff:g>, pictograme: <xliff:g id="ID_2">%2$s</xliff:g>, formă: <xliff:g id="ID_3">%3$s</xliff:g>, culoare: <xliff:g id="ID_4">%4$s</xliff:g>"</string>
     <string name="default_theme_title" msgid="2555741736622366797">"Standard"</string>
     <string name="preview_name_font" msgid="4465423899630037038">"Font"</string>
@@ -44,8 +42,8 @@
     <string name="preview_name_shape" msgid="5676971146080968721">"Formă"</string>
     <string name="preview_name_wallpaper" msgid="1738652462949531828">"Imagine de fundal"</string>
     <string name="font_card_title" msgid="2343292653502548685">"ABC • abc • 123"</string>
-    <string name="font_card_body" msgid="6790525594503904468">"Adaugă fonturile preferate pe fiecare ecran"</string>
-    <string name="grid_options_title" msgid="7071930966989877023">"Alege o dimensiune de grilă"</string>
+    <string name="font_card_body" msgid="6790525594503904468">"Adăugați fonturile preferate pe fiecare ecran"</string>
+    <string name="grid_options_title" msgid="7071930966989877023">"Alegeți o dimensiune de grilă"</string>
     <string name="grid_title_pattern" msgid="9188866567612607806">"<xliff:g id="ID_1">%1$d</xliff:g> x <xliff:g id="ID_2">%2$d</xliff:g>"</string>
     <string name="applied_theme_msg" msgid="3749018706366796244">"Stilul a fost setat"</string>
     <string name="applied_clock_msg" msgid="1303338016701443767">"Ceasul a fost setat"</string>
@@ -56,25 +54,25 @@
     <string name="custom_theme" msgid="1618351922263478163">"Personalizat"</string>
     <string name="custom_theme_title" msgid="2192300350332693631">"<xliff:g id="ID_1">%1$d</xliff:g> personalizat"</string>
     <string name="custom_theme_fragment_title" msgid="6615547284702040280">"Stil personalizat"</string>
-    <string name="custom_theme_delete" msgid="4744494663184126202">"Șterge"</string>
-    <string name="font_component_title" msgid="8800340833695292049">"Alege fontul"</string>
-    <string name="icon_component_title" msgid="5779787138399083903">"Alege pictogramele"</string>
-    <string name="color_component_title" msgid="1194089273921078816">"Alege culoarea"</string>
-    <string name="shape_component_title" msgid="8366847436022025538">"Alege o formă"</string>
-    <string name="name_component_title" msgid="532425087968663437">"Denumește stilul"</string>
+    <string name="custom_theme_delete" msgid="4744494663184126202">"Ștergeți"</string>
+    <string name="font_component_title" msgid="8800340833695292049">"Alegeți fontul"</string>
+    <string name="icon_component_title" msgid="5779787138399083903">"Alegeți pictogramele"</string>
+    <string name="color_component_title" msgid="1194089273921078816">"Alegeți culoarea"</string>
+    <string name="shape_component_title" msgid="8366847436022025538">"Alegeți o formă"</string>
+    <string name="name_component_title" msgid="532425087968663437">"Denumiți stilul"</string>
     <string name="icon_component_label" msgid="2625784884001407944">"Pictogramele <xliff:g id="ID_1">%1$d</xliff:g>"</string>
-    <string name="delete_custom_theme_confirmation" msgid="4452137183628769394">"Ștergi stilul personalizat?"</string>
-    <string name="delete_custom_theme_button" msgid="5102462988130208824">"Șterge"</string>
-    <string name="cancel" msgid="4651030493668562067">"Anulează"</string>
-    <string name="set_theme_wallpaper_dialog_message" msgid="2179661027350908003">"Setează imaginea de fundal pentru stil"</string>
-    <string name="use_style_instead_title" msgid="1578754995763917502">"Folosești <xliff:g id="ID_1">%1$s</xliff:g> în schimb?"</string>
-    <string name="use_style_instead_body" msgid="3051937045807471496">"Componentele pe care le-ai ales se potrivesc stilului <xliff:g id="ID_1">%1$s</xliff:g>. Dorești să folosești <xliff:g id="ID_2">%1$s</xliff:g> în schimb?"</string>
-    <string name="use_style_button" msgid="1754493078383627019">"Folosește <xliff:g id="ID_1">%1$s</xliff:g>"</string>
+    <string name="delete_custom_theme_confirmation" msgid="4452137183628769394">"Ștergeți stilul personalizat?"</string>
+    <string name="delete_custom_theme_button" msgid="5102462988130208824">"Ștergeți"</string>
+    <string name="cancel" msgid="4651030493668562067">"Anulați"</string>
+    <string name="set_theme_wallpaper_dialog_message" msgid="2179661027350908003">"Setați imaginea de fundal pentru stil"</string>
+    <string name="use_style_instead_title" msgid="1578754995763917502">"Folosiți <xliff:g id="ID_1">%1$s</xliff:g> în schimb?"</string>
+    <string name="use_style_instead_body" msgid="3051937045807471496">"Componentele pe care le-ați ales se potrivesc stilului <xliff:g id="ID_1">%1$s</xliff:g>. Doriți să folosiți <xliff:g id="ID_2">%1$s</xliff:g> în schimb?"</string>
+    <string name="use_style_button" msgid="1754493078383627019">"Folosiți <xliff:g id="ID_1">%1$s</xliff:g>"</string>
     <string name="no_thanks" msgid="7286616980115687627">"Nu, mulțumesc"</string>
     <string name="clock_preview_content_description" msgid="5460561185905717460">"Previzualizarea ceasului <xliff:g id="ID_1">%1$s</xliff:g>"</string>
     <string name="something_went_wrong" msgid="529840112449799117">"Hopa! Ceva nu a funcționat cum trebuie."</string>
     <string name="theme_preview_icons_section_title" msgid="7064768910744000643">"Culoare/pictograme"</string>
-    <string name="style_info_description" msgid="2612473574431003251">"Previzualizează fontul, pictogramele, forma aplicației și culoarea"</string>
+    <string name="style_info_description" msgid="2612473574431003251">"Previzualizați fontul, pictogramele, forma aplicației și culoarea"</string>
     <string name="accessibility_custom_font_title" msgid="966867359157303705">"Font personalizat"</string>
     <string name="accessibility_custom_icon_title" msgid="5753297905849062296">"Pictogramă personalizată"</string>
     <string name="accessibility_custom_color_title" msgid="4124246598886320663">"Culoare personalizată"</string>
@@ -85,7 +83,7 @@
     <string name="mode_changed" msgid="2243581369395418584">"Tema a fost schimbată"</string>
     <string name="themed_icon_title" msgid="7312460430471956558">"Pictograme tematice"</string>
     <string name="beta_title" msgid="8703819523760746458">"Beta"</string>
-    <string name="gird_picker_entry_content_description" msgid="9087651470212293439">"Schimbă grila de aplicații"</string>
+    <string name="gird_picker_entry_content_description" msgid="9087651470212293439">"Schimbați grila de aplicații"</string>
     <string name="wallpaper_color_tab" msgid="1447926591721403840">"Culori de fundal"</string>
     <string name="wallpaper_color_title" msgid="5687965239180986458">"Culoarea imaginii de fundal"</string>
     <string name="preset_color_tab" msgid="3133391839341329314">"Culori de bază"</string>
diff --git a/res/values-ru/strings.xml b/res/values-ru/strings.xml
index 9790be2..1a674ff 100644
--- a/res/values-ru/strings.xml
+++ b/res/values-ru/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Обои и стиль"</string>
     <string name="theme_title" msgid="2144932106319405101">"Стиль"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Настр. цифербл."</string>
-    <string name="clock_description" msgid="3563839327378948">"Выбер. цифербл."</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Выберите настраиваемый циферблат."</string>
+    <string name="clock_title" msgid="2126046720254613991">"Часы"</string>
     <string name="grid_title" msgid="1688173478777254123">"Сетка приложений"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Применить"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Нажмите, чтобы изменить"</string>
diff --git a/res/values-si/strings.xml b/res/values-si/strings.xml
index ab6b828..2e85b26 100644
--- a/res/values-si/strings.xml
+++ b/res/values-si/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"වෝල්පේපරය සහ මෝස්තරය"</string>
     <string name="theme_title" msgid="2144932106319405101">"විලාසය"</string>
-    <string name="clock_title" msgid="1974314575211361352">"අභිරුචි ඔරලෝසුව"</string>
-    <string name="clock_description" msgid="3563839327378948">"අභිරුචි ඔරලෝසුවක් තෝරන්න"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"අභිරුචි ඔරලෝසුවක් වෙනස් කරන්න"</string>
+    <string name="clock_title" msgid="2126046720254613991">"ඔරලෝසුව"</string>
     <string name="grid_title" msgid="1688173478777254123">"යෙදුම් ජාලකය"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"යොදන්න"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"සංස්කරණයට තට්ටු කරන්න"</string>
diff --git a/res/values-sk/strings.xml b/res/values-sk/strings.xml
index 5b78df5..7431dec 100644
--- a/res/values-sk/strings.xml
+++ b/res/values-sk/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Tapeta a štýl"</string>
     <string name="theme_title" msgid="2144932106319405101">"Štýl"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Vlastné hodiny"</string>
-    <string name="clock_description" msgid="3563839327378948">"Vyberte vlastné hodiny"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Zmeňte vlastné hodiny"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Hodiny"</string>
     <string name="grid_title" msgid="1688173478777254123">"Mriežka aplik."</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Použiť"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Klepnutím upravte"</string>
diff --git a/res/values-sl/strings.xml b/res/values-sl/strings.xml
index 7b9e67a..a637d4f 100644
--- a/res/values-sl/strings.xml
+++ b/res/values-sl/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Zaslonsko ozadje in slog"</string>
     <string name="theme_title" msgid="2144932106319405101">"Slog"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Ura po meri"</string>
-    <string name="clock_description" msgid="3563839327378948">"Izberite uro po meri"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Spremenite uro po meri"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Ura"</string>
     <string name="grid_title" msgid="1688173478777254123">"Mreža aplikacij"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Uporabi"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Dotaknite se za urejanje"</string>
diff --git a/res/values-sq/strings.xml b/res/values-sq/strings.xml
index a4ecd13..8f6259c 100644
--- a/res/values-sq/strings.xml
+++ b/res/values-sq/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Imazhi i sfondit dhe stili"</string>
     <string name="theme_title" msgid="2144932106319405101">"Stili"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Orë e personalizuar"</string>
-    <string name="clock_description" msgid="3563839327378948">"Orë e personalizuar"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Ndrysho orën e personalizuar"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Ora"</string>
     <string name="grid_title" msgid="1688173478777254123">"Rrjeta e aplikacioneve"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Zbato"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Trokit për të modifikuar"</string>
diff --git a/res/values-sr/strings.xml b/res/values-sr/strings.xml
index 61a99a8..3a7de2b 100644
--- a/res/values-sr/strings.xml
+++ b/res/values-sr/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Позадина и стил"</string>
     <string name="theme_title" msgid="2144932106319405101">"Стил"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Прилагођени сат"</string>
-    <string name="clock_description" msgid="3563839327378948">"Прилагођени сат"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Промените прилагођени сат"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Сат"</string>
     <string name="grid_title" msgid="1688173478777254123">"Мрежа апл."</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Примени"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Додирните да бисте изменили"</string>
diff --git a/res/values-sv/strings.xml b/res/values-sv/strings.xml
index 8fb2165..d16ff0f 100644
--- a/res/values-sv/strings.xml
+++ b/res/values-sv/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Bakgrund och utseende"</string>
     <string name="theme_title" msgid="2144932106319405101">"Format"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Anpassad klocka"</string>
-    <string name="clock_description" msgid="3563839327378948">"Välj anpassad klocka"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Ändra en anpassad klocka"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Klocka"</string>
     <string name="grid_title" msgid="1688173478777254123">"Apprutnät"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Använd"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Tryck för att redigera"</string>
diff --git a/res/values-sw/strings.xml b/res/values-sw/strings.xml
index ab035bf..1a01433 100644
--- a/res/values-sw/strings.xml
+++ b/res/values-sw/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Mandhari na mtindo"</string>
     <string name="theme_title" msgid="2144932106319405101">"Mtindo"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Saa Maalum"</string>
-    <string name="clock_description" msgid="3563839327378948">"Chagua saa maalum"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Badili saa maalum"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Saa"</string>
     <string name="grid_title" msgid="1688173478777254123">"Gridi ya programu"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Tumia"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Gusa ili ubadilishe"</string>
@@ -83,7 +81,7 @@
     <string name="mode_title" msgid="2394873501427436055">"Mandhari meusi"</string>
     <string name="mode_disabled_msg" msgid="9196245518435936512">"Imezimwa kwa muda kwa sababu ya Kiokoa Betri"</string>
     <string name="mode_changed" msgid="2243581369395418584">"Mandhari yamebadilishwa"</string>
-    <string name="themed_icon_title" msgid="7312460430471956558">"Aikoni za kujifanyia"</string>
+    <string name="themed_icon_title" msgid="7312460430471956558">"Aikoni zenye mada"</string>
     <string name="beta_title" msgid="8703819523760746458">"Beta"</string>
     <string name="gird_picker_entry_content_description" msgid="9087651470212293439">"Badilisha gridi ya programu"</string>
     <string name="wallpaper_color_tab" msgid="1447926591721403840">"Rangi za mandhari"</string>
diff --git a/res/values-ta/strings.xml b/res/values-ta/strings.xml
index e611b64..3a2bffb 100644
--- a/res/values-ta/strings.xml
+++ b/res/values-ta/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"வால்பேப்பரும் ஸ்டைலும்"</string>
     <string name="theme_title" msgid="2144932106319405101">"ஸ்டைல்"</string>
-    <string name="clock_title" msgid="1974314575211361352">"பிரத்தியேகக் கடிகாரம்"</string>
-    <string name="clock_description" msgid="3563839327378948">"பிரத்தியேகக் கடிகாரத்தைத் தேர்வுசெய்க"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"பிரத்தியேகக் கடிகாரத்தை மாற்றும்"</string>
+    <string name="clock_title" msgid="2126046720254613991">"கடிகாரம்"</string>
     <string name="grid_title" msgid="1688173478777254123">"ஆப்ஸ் கட்டம்"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"பயன்படுத்து"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"\'தீமைத்\' திருத்த தட்டவும்"</string>
diff --git a/res/values-te/strings.xml b/res/values-te/strings.xml
index 10a83cb..72fd0c3 100644
--- a/res/values-te/strings.xml
+++ b/res/values-te/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"వాల్‌పేపర్ &amp; స్టయిల్"</string>
     <string name="theme_title" msgid="2144932106319405101">"శైలి"</string>
-    <string name="clock_title" msgid="1974314575211361352">"అనుకూల గడియారం"</string>
-    <string name="clock_description" msgid="3563839327378948">"అనుకూల గడియారాన్ని ఎంచుకోండి"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"అనుకూల గడియారాన్ని మార్చండి"</string>
+    <string name="clock_title" msgid="2126046720254613991">"గడియారం"</string>
     <string name="grid_title" msgid="1688173478777254123">"యాప్ గ్రిడ్"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"వర్తింపజేయి"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"ఎడిట్ చేయడానికి నొక్కండి"</string>
diff --git a/res/values-th/strings.xml b/res/values-th/strings.xml
index 8e5956e..3375c30 100644
--- a/res/values-th/strings.xml
+++ b/res/values-th/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"วอลเปเปอร์และรูปแบบ"</string>
     <string name="theme_title" msgid="2144932106319405101">"รูปแบบ"</string>
-    <string name="clock_title" msgid="1974314575211361352">"นาฬิกาที่กำหนดเอง"</string>
-    <string name="clock_description" msgid="3563839327378948">"เลือกนาฬิกาที่กำหนดเอง"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"เปลี่ยนนาฬิกาที่กำหนดเอง"</string>
+    <string name="clock_title" msgid="2126046720254613991">"นาฬิกา"</string>
     <string name="grid_title" msgid="1688173478777254123">"ตารางกริดแอป"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"ใช้"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"แตะเพื่อแก้ไข"</string>
diff --git a/res/values-tl/strings.xml b/res/values-tl/strings.xml
index 72a5dc7..591a107 100644
--- a/res/values-tl/strings.xml
+++ b/res/values-tl/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Wallpaper &amp; istilo"</string>
     <string name="theme_title" msgid="2144932106319405101">"Istilo"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Custom na Orasan"</string>
-    <string name="clock_description" msgid="3563839327378948">"Pumili ng custom na orasan"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Magbago ng custom na orasan"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Orasan"</string>
     <string name="grid_title" msgid="1688173478777254123">"Grid ng app"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Ilapat"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"I-tap para ma-edit"</string>
diff --git a/res/values-tr/strings.xml b/res/values-tr/strings.xml
index ef52c16..e90cc22 100644
--- a/res/values-tr/strings.xml
+++ b/res/values-tr/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Duvar kağıdı ve stil"</string>
     <string name="theme_title" msgid="2144932106319405101">"Stil"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Özel Saat"</string>
-    <string name="clock_description" msgid="3563839327378948">"Özel saat seçin"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Özel saati değiştirin"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Saat"</string>
     <string name="grid_title" msgid="1688173478777254123">"Uygulama tablosu"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Uygula"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Düzenlemek için dokunun"</string>
diff --git a/res/values-uk/strings.xml b/res/values-uk/strings.xml
index c7660dc..4fd5c71 100644
--- a/res/values-uk/strings.xml
+++ b/res/values-uk/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Оформлення та стиль"</string>
     <string name="theme_title" msgid="2144932106319405101">"Стиль"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Свій циферблат"</string>
-    <string name="clock_description" msgid="3563839327378948">"Виберіть свій циферблат"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Змініть свій циферблат"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Годинник"</string>
     <string name="grid_title" msgid="1688173478777254123">"Сітка додатків"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Застосувати"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Торкніться, щоб змінити"</string>
@@ -86,7 +84,7 @@
     <string name="themed_icon_title" msgid="7312460430471956558">"Тема значків"</string>
     <string name="beta_title" msgid="8703819523760746458">"Бета"</string>
     <string name="gird_picker_entry_content_description" msgid="9087651470212293439">"Змінити сітку додатків"</string>
-    <string name="wallpaper_color_tab" msgid="1447926591721403840">"Кольори малюнка"</string>
+    <string name="wallpaper_color_tab" msgid="1447926591721403840">"Кольори фон. малюнка"</string>
     <string name="wallpaper_color_title" msgid="5687965239180986458">"Колір фонового малюнка"</string>
     <string name="preset_color_tab" msgid="3133391839341329314">"Основні кольори"</string>
     <string name="color_changed" msgid="7029571720331641235">"Колір змінено"</string>
diff --git a/res/values-ur/strings.xml b/res/values-ur/strings.xml
index a339231..8ae85d3 100644
--- a/res/values-ur/strings.xml
+++ b/res/values-ur/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"وال پیپر اور طرز"</string>
     <string name="theme_title" msgid="2144932106319405101">"طرز"</string>
-    <string name="clock_title" msgid="1974314575211361352">"حسب ضرورت گھڑی"</string>
-    <string name="clock_description" msgid="3563839327378948">"حسب ضرورت گھڑی چنیں"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"حسب ضرورت گھڑی کو تبدیل کریں"</string>
+    <string name="clock_title" msgid="2126046720254613991">"گھڑی"</string>
     <string name="grid_title" msgid="1688173478777254123">"ایپ گرڈ"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"لاگو کریں"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"ترمیم کرنے کے لیے تھپتھپائيں"</string>
diff --git a/res/values-uz/strings.xml b/res/values-uz/strings.xml
index d3fc6a8..44563b5 100644
--- a/res/values-uz/strings.xml
+++ b/res/values-uz/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Fon rasmi va uslubi"</string>
     <string name="theme_title" msgid="2144932106319405101">"Uslub"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Maxsus soat"</string>
-    <string name="clock_description" msgid="3563839327378948">"Maxsus soat tanlash"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Maxsus soatni almashtirish"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Soat"</string>
     <string name="grid_title" msgid="1688173478777254123">"Ilovalar jadvali"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Tatbiq etish"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Tahrirlash uchun tegining"</string>
diff --git a/res/values-vi/strings.xml b/res/values-vi/strings.xml
index 1489048..c078772 100644
--- a/res/values-vi/strings.xml
+++ b/res/values-vi/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Hình nền và phong cách"</string>
     <string name="theme_title" msgid="2144932106319405101">"Kiểu"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Đồng hồ tuỳ chỉnh"</string>
-    <string name="clock_description" msgid="3563839327378948">"Chọn đồng hồ tuỳ chỉnh"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Thay đổi đồng hồ tuỳ chỉnh"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Đồng hồ"</string>
     <string name="grid_title" msgid="1688173478777254123">"Lưới ứng dụng"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Áp dụng"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Nhấn để chỉnh sửa"</string>
diff --git a/res/values-w600dp-port/dimens.xml b/res/values-w600dp-port/dimens.xml
index ba92746..62a9946 100644
--- a/res/values-w600dp-port/dimens.xml
+++ b/res/values-w600dp-port/dimens.xml
@@ -17,8 +17,9 @@
 <resources>
     <!-- Dimensions for the customization option tiles -->
     <dimen name="option_tile_width">79dp</dimen>
-    <dimen name="option_tile_grid_padding_horizontal">8dp</dimen>
+    <dimen name="option_tile_linear_padding_horizontal">8dp</dimen>
 
-    <dimen name="component_color_chip_small_size_default">30dp</dimen>
+    <dimen name="component_color_chip_small_radius_default">30dp</dimen>
+    <dimen name="component_color_chip_small_diameter_default">60dp</dimen>
     <dimen name="color_seed_chip_margin">15dp</dimen>
 </resources>
diff --git a/res/values-w800dp/dimens.xml b/res/values-w800dp/dimens.xml
index 4cd6242..6ba900e 100644
--- a/res/values-w800dp/dimens.xml
+++ b/res/values-w800dp/dimens.xml
@@ -17,5 +17,5 @@
 <resources>
     <!-- Dimensions for the customization option tiles -->
     <dimen name="option_tile_width">87dp</dimen>
-    <dimen name="option_tile_grid_padding_horizontal">8dp</dimen>
+    <dimen name="option_tile_linear_padding_horizontal">8dp</dimen>
 </resources>
\ No newline at end of file
diff --git a/res/values-zh-rCN/strings.xml b/res/values-zh-rCN/strings.xml
index 654da3a..1a20566 100644
--- a/res/values-zh-rCN/strings.xml
+++ b/res/values-zh-rCN/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"壁纸和样式"</string>
     <string name="theme_title" msgid="2144932106319405101">"样式"</string>
-    <string name="clock_title" msgid="1974314575211361352">"自定义钟面"</string>
-    <string name="clock_description" msgid="3563839327378948">"选择自定义钟面"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"更改自定义钟面"</string>
+    <string name="clock_title" msgid="2126046720254613991">"时钟"</string>
     <string name="grid_title" msgid="1688173478777254123">"应用网格"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"应用"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"点按即可修改"</string>
diff --git a/res/values-zh-rHK/strings.xml b/res/values-zh-rHK/strings.xml
index a06494b..df0972c 100644
--- a/res/values-zh-rHK/strings.xml
+++ b/res/values-zh-rHK/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"桌布和樣式"</string>
     <string name="theme_title" msgid="2144932106319405101">"樣式"</string>
-    <string name="clock_title" msgid="1974314575211361352">"自訂時鐘"</string>
-    <string name="clock_description" msgid="3563839327378948">"揀選自訂時鐘"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"變更自訂時鐘"</string>
+    <string name="clock_title" msgid="2126046720254613991">"時鐘"</string>
     <string name="grid_title" msgid="1688173478777254123">"應用程式網格"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"套用"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"輕按即可編輯"</string>
diff --git a/res/values-zh-rTW/strings.xml b/res/values-zh-rTW/strings.xml
index 6c7dbb5..478d759 100644
--- a/res/values-zh-rTW/strings.xml
+++ b/res/values-zh-rTW/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"桌布和樣式"</string>
     <string name="theme_title" msgid="2144932106319405101">"樣式"</string>
-    <string name="clock_title" msgid="1974314575211361352">"自訂時鐘"</string>
-    <string name="clock_description" msgid="3563839327378948">"選擇自訂時鐘"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"變更自訂時鐘"</string>
+    <string name="clock_title" msgid="2126046720254613991">"時鐘"</string>
     <string name="grid_title" msgid="1688173478777254123">"應用程式格線"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"套用"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"輕觸這裡即可編輯"</string>
diff --git a/res/values-zu/strings.xml b/res/values-zu/strings.xml
index ebdf004..e399001 100644
--- a/res/values-zu/strings.xml
+++ b/res/values-zu/strings.xml
@@ -19,9 +19,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name" msgid="1647136562008520313">"Isithombe sangemuva nesitayela"</string>
     <string name="theme_title" msgid="2144932106319405101">"Isitayela"</string>
-    <string name="clock_title" msgid="1974314575211361352">"Iwashi Elingokomuntu Ngamunye"</string>
-    <string name="clock_description" msgid="3563839327378948">"Khetha iwashi elingokomuntu ngamunye"</string>
-    <string name="clock_picker_entry_content_description" msgid="8377139273468595734">"Shintsha iwashi elingokomuntu ngamunye"</string>
+    <string name="clock_title" msgid="2126046720254613991">"Iwashi"</string>
     <string name="grid_title" msgid="1688173478777254123">"Igridi ye-app"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Faka"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Thepha ukuze uhlele"</string>
diff --git a/res/values/dimens.xml b/res/values/dimens.xml
index 0ad221e..64d9941 100644
--- a/res/values/dimens.xml
+++ b/res/values/dimens.xml
@@ -38,7 +38,12 @@
     <dimen name="option_tile_margin_horizontal">6dp</dimen>
     <dimen name="option_tile_padding_vertical">12dp</dimen>
     <dimen name="option_tile_padding_horizontal">12dp</dimen>
-    <dimen name="option_tile_grid_padding_horizontal">4dp</dimen>
+    <!-- Spacing between tiles in linear layout -->
+    <dimen name="option_tile_linear_padding_horizontal">4dp</dimen>
+    <!-- Minimum padding around entire tile in grid layout -->
+    <dimen name="option_tile_grid_tile_padding_min">2dp</dimen>
+    <!-- Minimum padding around icon within tile in grid layout -->
+    <dimen name="option_tile_grid_icon_padding_min">4dp</dimen>
     <dimen name="option_icon_size">16dp</dimen>
     <dimen name="theme_option_icon_sample_height">22dp</dimen>
     <dimen name="theme_option_icon_sample_width">22dp</dimen>
@@ -131,8 +136,15 @@
     <!-- For the color page. -->
     <dimen name="color_page_indicator_margin_top">16dp</dimen>
 
-    <dimen name="component_color_chip_small_size_default">29dp</dimen>
-    <dimen name="color_seed_option_tile_padding">10dp</dimen>
-    <dimen name="color_seed_option_tile_padding_selected">6dp</dimen>
+    <dimen name="component_color_chip_small_radius_default">29dp</dimen>
+    <dimen name="component_color_chip_small_diameter_default">58dp</dimen>
     <dimen name="color_seed_chip_margin">14dp</dimen>
+
+    <!-- Keyguard quick affordances -->
+    <!-- Size for the container for the icon of a quick affordance for the lock screen in the picker experience. -->
+    <dimen name="keyguard_quick_affordance_icon_container_size">74dp</dimen>
+    <!-- Size for the icon of a quick affordance for the lock screen in the picker experience. -->
+    <dimen name="keyguard_quick_affordance_icon_size">24dp</dimen>
+    <!-- Width of a single selectable item in the lock screen quick affordance picker. -->
+    <dimen name="keyguard_quick_affordance_picker_item_width">74dp</dimen>
 </resources>
diff --git a/res/values/ids.xml b/res/values/ids.xml
new file mode 100644
index 0000000..1ed004d
--- /dev/null
+++ b/res/values/ids.xml
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?><!--
+  ~ 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.
+  ~
+  -->
+
+<resources>
+    <item name="start_affordance" type="id" />
+    <item name="end_affordance" type="id" />
+    <item name="slot_tabs" type="id" />
+    <item name="affordances" type="id" />
+</resources>
diff --git a/res/values/strings.xml b/res/values/strings.xml
index 7aef401..63fb560 100755
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -267,4 +267,81 @@
     <!-- Title of a section of color selection option that obtains colors automatically from the
         wallpaper instead of a set color [CHAR LIMIT=15] -->
     <string name="adaptive_color_title">Dynamic</string>
+
+    <!--
+    Name of the slot on the "start" side of the bottom of the lock screen, where quick affordance
+    buttons can be added to the lock screen. In left-to-right languages, this is the left-hand side
+    button. In right-to-left languages, this is the right-hand side button. [CHAR LIMIT=16].
+    -->
+    <string name="keyguard_slot_name_bottom_start">Left button</string>
+
+    <!--
+    Name of the slot on the "end" side of the bottom of the lock screen, where quick affordance
+    buttons can be added to the lock screen. In left-to-right languages, this is the right-hand side
+    button. In right-to-left languages, this is the left-hand side button. [CHAR LIMIT=16].
+    -->
+    <string name="keyguard_slot_name_bottom_end">Right button</string>
+
+    <!--
+    Name for an option to have no quick affordance selected for one of the sides of the lock
+    screen. We show this as an option in a settings experience, where users get to choose which
+    quick affordances (or buttons) are available on their device's lock screen. [CHAR LIMIT=10].
+    -->
+    <string name="keyguard_affordance_none">None</string>
+
+    <!--
+    Title for a popup dialog shown when the user attempts to select an option that is not currently
+    enabled. The dialog contains a list of instructions that the user needs to take in order to
+    enable the option before it can be selected again. [CHAR LIMIT=NONE].
+    -->
+    <string name="keyguard_affordance_enablement_dialog_title">Additional setup needed</string>
+
+    <!--
+    Template for an action that opens a specific app. [CHAR LIMIT=16]
+    -->
+    <string name="keyguard_affordance_enablement_dialog_action_template">Open <xliff:g id="appName" example="Wallet">%1$s</xliff:g></string>
+
+    <!--
+    Template for a message shown right before a list of instructions that tell the user what to do
+    in order to enable a shortcut to a specific app. [CHAR LIMIT=NONE]
+    -->
+    <string name="keyguard_affordance_enablement_dialog_message">To add the <xliff:g id="appName" example="Wallet">%1$s</xliff:g> app as a shortcut, make sure</string>
+
+    <!--
+    Label for button in a dialog shown to the user with a list of instructions that the user should
+    follow in order to make a piece of functionality available as a lock screen quick affordance.
+    [CHAR LIMIT=10].
+    -->
+    <string name="keyguard_affordance_enablement_dialog_dismiss_button">Done</string>
+
+    <!--
+    Title for a screen where the user can configure the lock screen shortcut buttons that appear on
+    the device without unlocking.
+    [CHAR LIMIT=32].
+    -->
+    <string name="keyguard_quick_affordance_title">Shortcuts</string>
+
+    <!--
+    Label for a menu item on a settings screen that helps the user open a new screen where they can
+    configure the lock screen shortcut buttons that appear on the device without unlocking.
+    [CHAR LIMIT=16].
+    -->
+    <string name="keyguard_quick_affordance_section_title">Shortcuts</string>
+
+    <!--
+    Template for text that shows the names of two currently-selected lock screen shortcuts on the
+    lock screen. For example, it may say "Camera, Wallet", if the first selected shortcut opens the
+    camera app and the second one opens the tap-to-pay wallet experience.
+    [CHAR LIMIT=60].
+    -->
+    <string name="keyguard_quick_affordance_two_selected_template"><xliff:g id="first">%1$s</xliff:g>, <xliff:g id="second">%2$s</xliff:g></string>
+
+    <!--
+    Placeholder text that shows when no lock screen shortcuts are currently selected on the lock
+    screen. When selected, "None" is replaced by another string that shows what is currently
+    selected. For example, it may say "Camera, Wallet", if the first selected shortcut opens the
+    camera app and the second one opens the tap-to-pay wallet experience.
+    [CHAR LIMIT=60].
+    -->
+    <string name="keyguard_quick_affordance_none_selected">None</string>
 </resources>
diff --git a/robolectric_tests/src/com/android/customization/picker/clock/ClockCustomDemoFragmentTest.kt b/robolectric_tests/src/com/android/customization/picker/clock/ClockCustomDemoFragmentTest.kt
new file mode 100644
index 0000000..5f4c134
--- /dev/null
+++ b/robolectric_tests/src/com/android/customization/picker/clock/ClockCustomDemoFragmentTest.kt
@@ -0,0 +1,99 @@
+package com.android.customization.picker.clock
+
+import android.os.Handler
+import android.os.UserHandle
+import android.view.View
+import androidx.appcompat.app.AppCompatActivity
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.RecyclerView
+import com.android.systemui.plugins.ClockId
+import com.android.systemui.plugins.ClockMetadata
+import com.android.systemui.plugins.ClockProviderPlugin
+import com.android.systemui.plugins.PluginManager
+import com.android.systemui.shared.clocks.ClockRegistry
+import com.android.systemui.shared.clocks.DefaultClockProvider
+import org.junit.Assert
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.Mock
+import org.mockito.Mockito
+import org.mockito.MockitoAnnotations
+import org.robolectric.Robolectric
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+/** Tests of [ClockCustomDemoFragment]. */
+@RunWith(RobolectricTestRunner::class)
+@Config(manifest = Config.NONE)
+class ClockCustomDemoFragmentTest {
+    private lateinit var mActivity: AppCompatActivity
+    private var mClockCustomDemoFragment: ClockCustomDemoFragment? = null
+    private lateinit var registry: ClockRegistry
+    @Mock private lateinit var mockPluginManager: PluginManager
+    @Mock private lateinit var mockHandler: Handler
+    @Mock private lateinit var fakePlugin: ClockProviderPlugin
+    @Mock private lateinit var defaultClockProvider: DefaultClockProvider
+
+    private var settingValue: String = ""
+
+    @Before
+    fun setUp() {
+        MockitoAnnotations.initMocks(this)
+        mActivity = Robolectric.buildActivity(AppCompatActivity::class.java).get()
+        mClockCustomDemoFragment = ClockCustomDemoFragment()
+        Mockito.`when`(defaultClockProvider.getClocks())
+            .thenReturn(listOf(ClockMetadata("DEFAULT", "Default Clock")))
+        registry =
+            object :
+                ClockRegistry(
+                    mActivity,
+                    mockPluginManager,
+                    mockHandler,
+                    isEnabled = true,
+                    userHandle = UserHandle.USER_ALL,
+                    defaultClockProvider = defaultClockProvider
+                ) {
+                override var currentClockId: ClockId
+                    get() = settingValue
+                    set(value) {
+                        settingValue = value
+                    }
+
+                override fun getClocks(): List<ClockMetadata> {
+                    return defaultClockProvider.getClocks() +
+                        listOf(
+                            ClockMetadata("CLOCK_1", "Clock 1"),
+                            ClockMetadata("CLOCK_2", "Clock 2"),
+                            ClockMetadata("CLOCK_NOT_IN_USE", "Clock not in use")
+                        )
+                }
+            }
+
+        mClockCustomDemoFragment!!.clockRegistry = registry
+        mClockCustomDemoFragment!!.recyclerView = RecyclerView(mActivity)
+        mClockCustomDemoFragment!!.recyclerView.layoutManager =
+            LinearLayoutManager(mActivity, RecyclerView.VERTICAL, false)
+        mClockCustomDemoFragment!!.pluginListener.onPluginConnected(fakePlugin, mActivity)
+    }
+
+    @Test
+    fun testItemCount_getCorrectClockCount() {
+        Assert.assertEquals(3, mClockCustomDemoFragment!!.recyclerView.adapter!!.itemCount)
+    }
+
+    @Test
+    fun testClick_setCorrectClockId() {
+        mClockCustomDemoFragment!!
+            .recyclerView
+            .measure(View.MeasureSpec.UNSPECIFIED, View.MeasureSpec.UNSPECIFIED)
+        mClockCustomDemoFragment!!.recyclerView.layout(0, 0, 100, 10000)
+        val testPosition = 1
+        mClockCustomDemoFragment!!
+            .recyclerView
+            .findViewHolderForAdapterPosition(testPosition)
+            ?.itemView
+            ?.performClick()
+        Assert.assertEquals("CLOCK_1", settingValue)
+    }
+}
diff --git a/src/com/android/customization/model/clock/ClockSectionController.java b/src/com/android/customization/model/clock/ClockSectionController.java
index 8f98b88..545c1c4 100644
--- a/src/com/android/customization/model/clock/ClockSectionController.java
+++ b/src/com/android/customization/model/clock/ClockSectionController.java
@@ -20,7 +20,7 @@
 
 import androidx.annotation.Nullable;
 
-import com.android.customization.picker.clock.ClockCustomFragment;
+import com.android.customization.picker.clock.ClockCustomDemoFragment;
 import com.android.customization.picker.clock.ClockSectionView;
 import com.android.wallpaper.R;
 import com.android.wallpaper.config.Flags;
@@ -37,7 +37,7 @@
 
     @Override
     public boolean isAvailable(@Nullable Context context) {
-        return Flags.enableClockCustomization;
+        return Flags.enableCustomClocks;
     }
 
     @Override
@@ -45,7 +45,8 @@
         ClockSectionView view = (ClockSectionView) LayoutInflater.from(context).inflate(
                 R.layout.clock_section_view,
                 null);
-        view.setOnClickListener(v -> mNavigationController.navigateTo(new ClockCustomFragment()));
+        view.setOnClickListener(v ->
+                mNavigationController.navigateTo(new ClockCustomDemoFragment()));
         return view;
     }
 }
diff --git a/src/com/android/customization/model/color/ColorBundle.java b/src/com/android/customization/model/color/ColorBundle.java
index dc5a367..d34f3fc 100644
--- a/src/com/android/customization/model/color/ColorBundle.java
+++ b/src/com/android/customization/model/color/ColorBundle.java
@@ -15,18 +15,11 @@
  */
 package com.android.customization.model.color;
 
-import static com.android.customization.model.ResourceConstants.PATH_SIZE;
-
 import android.content.Context;
 import android.content.res.Configuration;
 import android.content.res.Resources;
 import android.graphics.Color;
-import android.graphics.Path;
 import android.graphics.PorterDuff;
-import android.graphics.drawable.Drawable;
-import android.graphics.drawable.ShapeDrawable;
-import android.graphics.drawable.shapes.PathShape;
-import android.text.TextUtils;
 import android.view.View;
 import android.widget.ImageView;
 
@@ -34,16 +27,13 @@
 import androidx.annotation.Dimension;
 import androidx.annotation.NonNull;
 import androidx.annotation.VisibleForTesting;
-import androidx.core.graphics.PathParser;
 
 import com.android.customization.model.ResourceConstants;
 import com.android.systemui.monet.Style;
 import com.android.wallpaper.R;
 
-import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
 
 /**
@@ -65,15 +55,11 @@
         Resources res = view.getContext().getResources();
         int primaryColor = mPreviewInfo.resolvePrimaryColor(res);
         int secondaryColor = mPreviewInfo.resolveSecondaryColor(res);
-        int padding = view.isActivated()
-                ? res.getDimensionPixelSize(R.dimen.color_seed_option_tile_padding_selected)
-                : res.getDimensionPixelSize(R.dimen.color_seed_option_tile_padding);
 
         for (int i = 0; i < mPreviewColorIds.length; i++) {
             ImageView colorPreviewImageView = view.findViewById(mPreviewColorIds[i]);
             int color = i % 2 == 0 ? primaryColor : secondaryColor;
             colorPreviewImageView.getDrawable().setColorFilter(color, PorterDuff.Mode.SRC);
-            colorPreviewImageView.setPadding(padding, padding, padding, padding);
         }
         view.setContentDescription(getContentDescription(view.getContext()));
     }
@@ -103,8 +89,6 @@
         // Monet system palette and accent colors
         @ColorInt public final int primaryColorLight;
         @ColorInt public final int primaryColorDark;
-        public final List<Drawable> icons;
-        public final Drawable shapeDrawable;
         @Dimension
         public final int bottomSheetCornerRadius;
 
@@ -115,14 +99,11 @@
 
         private PreviewInfo(
                 int secondaryColorLight, int secondaryColorDark, int colorSystemPaletteLight,
-                int primaryColorDark, List<Drawable> icons, Drawable shapeDrawable,
-                @Dimension int cornerRadius) {
+                int primaryColorDark, @Dimension int cornerRadius) {
             this.secondaryColorLight = secondaryColorLight;
             this.secondaryColorDark = secondaryColorDark;
             this.primaryColorLight = colorSystemPaletteLight;
             this.primaryColorDark = primaryColorDark;
-            this.icons = icons;
-            this.shapeDrawable = shapeDrawable;
             this.bottomSheetCornerRadius = cornerRadius;
         }
 
@@ -188,7 +169,6 @@
         // System and Monet colors
         @ColorInt private int mPrimaryColorLight = Color.TRANSPARENT;
         @ColorInt private int mPrimaryColorDark = Color.TRANSPARENT;
-        private List<Drawable> mIcons = new ArrayList<>();
         private boolean mIsDefault;
         private Style mStyle = Style.TONAL_SPOT;
         private int mIndex;
@@ -213,26 +193,12 @@
          * @return the {@link PreviewInfo} object
          */
         public PreviewInfo createPreviewInfo(@NonNull Context context) {
-            ShapeDrawable shapeDrawable = null;
             Resources system = context.getResources().getSystem();
-            String pathString = system.getString(
-                    system.getIdentifier(ResourceConstants.CONFIG_ICON_MASK,
-                            "string", ResourceConstants.ANDROID_PACKAGE));
-            Path path = null;
-            if (!TextUtils.isEmpty(pathString)) {
-                path = PathParser.createPathFromPathData(pathString);
-            }
-            if (path != null) {
-                PathShape shape = new PathShape(path, PATH_SIZE, PATH_SIZE);
-                shapeDrawable = new ShapeDrawable(shape);
-                shapeDrawable.setIntrinsicHeight((int) PATH_SIZE);
-                shapeDrawable.setIntrinsicWidth((int) PATH_SIZE);
-            }
             return new PreviewInfo(mSecondaryColorLight,
-                    mSecondaryColorDark, mPrimaryColorLight, mPrimaryColorDark, mIcons,
-                    shapeDrawable, system.getDimensionPixelOffset(
-                    system.getIdentifier(ResourceConstants.CONFIG_CORNERRADIUS,
-                            "dimen", ResourceConstants.ANDROID_PACKAGE)));
+                    mSecondaryColorDark, mPrimaryColorLight, mPrimaryColorDark,
+                    system.getDimensionPixelOffset(
+                            system.getIdentifier(ResourceConstants.CONFIG_CORNERRADIUS, "dimen",
+                                    ResourceConstants.ANDROID_PACKAGE)));
         }
 
         public Map<String, String> getPackages() {
@@ -298,16 +264,6 @@
         }
 
         /**
-         * Sets icon for bundle
-         * @param icon icon in {@link Drawable}
-         * @return this of {@link Builder}
-         */
-        public Builder addIcon(Drawable icon) {
-            mIcons.add(icon);
-            return this;
-        }
-
-        /**
          * Sets overlay package for bundle
          * @param category the category of bundle
          * @param packageName tha name of package in the category
diff --git a/src/com/android/customization/model/color/ColorBundlePreviewExtractor.java b/src/com/android/customization/model/color/ColorBundlePreviewExtractor.java
index b67eec8..55b637f 100644
--- a/src/com/android/customization/model/color/ColorBundlePreviewExtractor.java
+++ b/src/com/android/customization/model/color/ColorBundlePreviewExtractor.java
@@ -15,18 +15,12 @@
  */
 package com.android.customization.model.color;
 
-import static com.android.customization.model.ResourceConstants.ANDROID_PACKAGE;
-import static com.android.customization.model.ResourceConstants.ICONS_FOR_PREVIEW;
 import static com.android.customization.model.ResourceConstants.OVERLAY_CATEGORY_COLOR;
 import static com.android.customization.model.ResourceConstants.OVERLAY_CATEGORY_SYSTEM_PALETTE;
 import static com.android.customization.model.color.ColorUtils.toColorString;
 
 import android.content.Context;
 import android.content.pm.PackageManager;
-import android.content.pm.PackageManager.NameNotFoundException;
-import android.content.res.Resources;
-import android.content.res.Resources.NotFoundException;
-import android.graphics.drawable.Drawable;
 import android.text.TextUtils;
 import android.util.Log;
 
@@ -80,26 +74,4 @@
         }
         builder.setStyle(s);
     }
-
-    void addAndroidIconOverlay(ColorBundle.Builder builder) throws NameNotFoundException {
-        addSystemDefaultIcons(builder, ICONS_FOR_PREVIEW);
-    }
-
-    void addSystemDefaultIcons(ColorBundle.Builder builder, String... previewIcons) {
-        try {
-            for (String iconName : previewIcons) {
-                builder.addIcon(loadIconPreviewDrawable(iconName));
-            }
-        } catch (NameNotFoundException | NotFoundException e) {
-            Log.w(TAG, "Didn't find android package icons, will skip preview", e);
-        }
-    }
-
-    Drawable loadIconPreviewDrawable(String drawableName)
-            throws NameNotFoundException, NotFoundException {
-        Resources packageRes = mPackageManager.getResourcesForApplication(ANDROID_PACKAGE);
-        Resources res = Resources.getSystem();
-        return res.getDrawable(packageRes.getIdentifier(drawableName, "drawable",
-                        ANDROID_PACKAGE), null);
-    }
 }
diff --git a/src/com/android/customization/model/color/ColorProvider.kt b/src/com/android/customization/model/color/ColorProvider.kt
index a63f904..c1a4552 100644
--- a/src/com/android/customization/model/color/ColorProvider.kt
+++ b/src/com/android/customization/model/color/ColorProvider.kt
@@ -19,7 +19,6 @@
 import android.content.Context
 import android.content.res.ColorStateList
 import android.content.res.Resources
-import android.text.TextUtils
 import androidx.annotation.ColorInt
 import androidx.core.graphics.ColorUtils.setAlphaComponent
 import androidx.lifecycle.LifecycleOwner
@@ -29,8 +28,8 @@
 import com.android.customization.model.ResourceConstants.COLOR_BUNDLE_MAIN_COLOR_PREFIX
 import com.android.customization.model.ResourceConstants.COLOR_BUNDLE_NAME_PREFIX
 import com.android.customization.model.ResourceConstants.COLOR_BUNDLE_STYLE_PREFIX
-import com.android.customization.model.ResourceConstants.OVERLAY_CATEGORY_SYSTEM_PALETTE
 import com.android.customization.model.ResourceConstants.OVERLAY_CATEGORY_COLOR
+import com.android.customization.model.ResourceConstants.OVERLAY_CATEGORY_SYSTEM_PALETTE
 import com.android.customization.model.ResourcesApkProvider
 import com.android.customization.model.color.ColorOptionsProvider.COLOR_SOURCE_HOME
 import com.android.customization.model.color.ColorOptionsProvider.COLOR_SOURCE_LOCK
@@ -38,20 +37,20 @@
 import com.android.systemui.monet.ColorScheme
 import com.android.systemui.monet.Style
 import com.android.wallpaper.compat.WallpaperManagerCompat
+import com.android.wallpaper.config.Flags
 import com.android.wallpaper.module.InjectorProvider
+import java.util.*
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
-import java.util.*
 
 /**
- * Default implementation of {@link ColorOptionsProvider} that reads preset colors from
- * a stub APK.
+ * Default implementation of {@link ColorOptionsProvider} that reads preset colors from a stub APK.
  */
 class ColorProvider(context: Context, stubPackageName: String) :
-        ResourcesApkProvider(context, stubPackageName), ColorOptionsProvider {
+    ResourcesApkProvider(context, stubPackageName), ColorOptionsProvider {
 
     companion object {
         const val themeStyleEnabled = true
@@ -64,36 +63,41 @@
 
     private val monetEnabled = ColorUtils.isMonetEnabled(context)
     // TODO(b/202145216): Use style method to fetch the list of style.
-    private var styleList = if (themeStyleEnabled) arrayOf(
-        Style.TONAL_SPOT, Style.SPRITZ, Style.VIBRANT, Style.EXPRESSIVE
-    ) else arrayOf(Style.TONAL_SPOT)
+    private var styleList =
+        if (themeStyleEnabled)
+            arrayOf(Style.TONAL_SPOT, Style.SPRITZ, Style.VIBRANT, Style.EXPRESSIVE)
+        else arrayOf(Style.TONAL_SPOT)
 
-    private val scope = if (mContext is LifecycleOwner) {
-        mContext.lifecycleScope
-    } else {
-        CoroutineScope(Dispatchers.Default + SupervisorJob())
-    }
+    private val scope =
+        if (mContext is LifecycleOwner) {
+            mContext.lifecycleScope
+        } else {
+            CoroutineScope(Dispatchers.Default + SupervisorJob())
+        }
 
     private var colorsAvailable = true
     private var colorBundles: List<ColorOption>? = null
     private var homeWallpaperColors: WallpaperColors? = null
     private var lockWallpaperColors: WallpaperColors? = null
 
-
     override fun isAvailable(): Boolean {
         return monetEnabled && super.isAvailable() && colorsAvailable
     }
 
-    override fun fetch(callback: OptionsFetchedListener<ColorOption>?, reload: Boolean,
-                       homeWallpaperColors: WallpaperColors?,
-                       lockWallpaperColors: WallpaperColors?) {
-        val wallpaperColorsChanged = this.homeWallpaperColors != homeWallpaperColors
-                || this.lockWallpaperColors != lockWallpaperColors
+    override fun fetch(
+        callback: OptionsFetchedListener<ColorOption>?,
+        reload: Boolean,
+        homeWallpaperColors: WallpaperColors?,
+        lockWallpaperColors: WallpaperColors?
+    ) {
+        val wallpaperColorsChanged =
+            this.homeWallpaperColors != homeWallpaperColors ||
+                this.lockWallpaperColors != lockWallpaperColors
         if (wallpaperColorsChanged) {
             this.homeWallpaperColors = homeWallpaperColors
             this.lockWallpaperColors = lockWallpaperColors
         }
-        if(colorBundles == null || reload || wallpaperColorsChanged) {
+        if (colorBundles == null || reload || wallpaperColorsChanged) {
             scope.launch {
                 try {
                     if (colorBundles == null || reload) {
@@ -119,46 +123,56 @@
         // is the most recently set wallpaper
         val manager = InjectorProvider.getInjector().getWallpaperManagerCompat(mContext)
         return manager.getWallpaperId(WallpaperManagerCompat.FLAG_LOCK) >
-                manager.getWallpaperId(WallpaperManagerCompat.FLAG_SYSTEM)
+            manager.getWallpaperId(WallpaperManagerCompat.FLAG_SYSTEM)
     }
 
-    private fun loadSeedColors(homeWallpaperColors: WallpaperColors?,
-                               lockWallpaperColors: WallpaperColors?) {
+    private fun loadSeedColors(
+        homeWallpaperColors: WallpaperColors?,
+        lockWallpaperColors: WallpaperColors?
+    ) {
         if (homeWallpaperColors == null) return
 
         val bundles: MutableList<ColorOption> = ArrayList()
-        val colorsPerSource = if (lockWallpaperColors == null) {
-            MAX_SEED_COLORS
-        } else {
-            MAX_SEED_COLORS / 2
-        }
+        val colorsPerSource =
+            if (lockWallpaperColors == null) {
+                MAX_SEED_COLORS
+            } else {
+                MAX_SEED_COLORS / 2
+            }
 
         if (lockWallpaperColors != null) {
             val shouldLockColorsGoFirst = isLockScreenWallpaperLastApplied()
             // First half of the colors
             buildColorSeeds(
-                    if (shouldLockColorsGoFirst) lockWallpaperColors else homeWallpaperColors,
-                    colorsPerSource,
-                    if (shouldLockColorsGoFirst) COLOR_SOURCE_LOCK else COLOR_SOURCE_HOME,
-                    true,
-                    bundles)
+                if (shouldLockColorsGoFirst) lockWallpaperColors else homeWallpaperColors,
+                colorsPerSource,
+                if (shouldLockColorsGoFirst) COLOR_SOURCE_LOCK else COLOR_SOURCE_HOME,
+                true,
+                bundles
+            )
             // Second half of the colors
             buildColorSeeds(
-                    if (shouldLockColorsGoFirst) homeWallpaperColors else lockWallpaperColors,
-                    MAX_SEED_COLORS - bundles.size / styleSize,
-                    if (shouldLockColorsGoFirst) COLOR_SOURCE_HOME else COLOR_SOURCE_LOCK,
-                    false,
-                    bundles)
+                if (shouldLockColorsGoFirst) homeWallpaperColors else lockWallpaperColors,
+                MAX_SEED_COLORS - bundles.size / styleSize,
+                if (shouldLockColorsGoFirst) COLOR_SOURCE_HOME else COLOR_SOURCE_LOCK,
+                false,
+                bundles
+            )
         } else {
             buildColorSeeds(homeWallpaperColors, colorsPerSource, COLOR_SOURCE_HOME, true, bundles)
         }
 
-        bundles.addAll(colorBundles?.filterNot{it is ColorSeedOption} ?: emptyList())
+        bundles.addAll(colorBundles?.filterNot { it is ColorSeedOption } ?: emptyList())
         colorBundles = bundles
     }
 
-    private fun buildColorSeeds(wallpaperColors: WallpaperColors, maxColors: Int, source: String,
-                                containsDefault: Boolean, bundles: MutableList<ColorOption>) {
+    private fun buildColorSeeds(
+        wallpaperColors: WallpaperColors,
+        maxColors: Int,
+        source: String,
+        containsDefault: Boolean,
+        bundles: MutableList<ColorOption>
+    ) {
         val seedColors = ColorScheme.getSeedColors(wallpaperColors)
         val defaultSeed = seedColors.first()
         buildBundle(defaultSeed, 0, containsDefault, source, bundles)
@@ -167,19 +181,27 @@
         }
     }
 
-    private fun buildBundle(colorInt: Int, i: Int, isDefault: Boolean, source: String,
-                            bundles: MutableList<ColorOption>) {
+    private fun buildBundle(
+        colorInt: Int,
+        i: Int,
+        isDefault: Boolean,
+        source: String,
+        bundles: MutableList<ColorOption>
+    ) {
         // TODO(b/202145216): Measure time cost in the loop.
         for (style in styleList) {
             val builder = ColorSeedOption.Builder()
             val lightColorScheme = ColorScheme(colorInt, /* darkTheme= */ false, style)
             val darkColorScheme = ColorScheme(colorInt, /* darkTheme= */ true, style)
-            builder.setLightColors(lightColorScheme.getLightColorPreview())
+            builder
+                .setLightColors(lightColorScheme.getLightColorPreview())
                 .setDarkColors(darkColorScheme.getDarkColorPreview())
-                .addOverlayPackage(OVERLAY_CATEGORY_SYSTEM_PALETTE,
+                .addOverlayPackage(
+                    OVERLAY_CATEGORY_SYSTEM_PALETTE,
                     if (isDefault) "" else toColorString(colorInt)
                 )
-                .addOverlayPackage(OVERLAY_CATEGORY_COLOR,
+                .addOverlayPackage(
+                    OVERLAY_CATEGORY_COLOR,
                     if (isDefault) "" else toColorString(colorInt)
                 )
                 .setSource(source)
@@ -194,88 +216,96 @@
     }
 
     /**
-     * Returns the colors for the light theme version of the preview of a ColorScheme
-     * based on this order:
-     * |-------|
-     * | 0 | 1 |
-     * |---+---|
-     * | 2 | 3 |
-     * |-------|
+     * Returns the colors for the light theme version of the preview of a ColorScheme based on this
+     * order: |-------| | 0 | 1 | |---+---| | 2 | 3 | |-------|
      */
     @ColorInt
     private fun ColorScheme.getLightColorPreview(): IntArray {
-        return intArrayOf(setAlphaComponent(this.accent1[2], ALPHA_MASK),
-                setAlphaComponent(this.accent1[2], ALPHA_MASK),
-                ColorStateList.valueOf(this.accent3[6]).withLStar(85f).colors[0],
-                setAlphaComponent(this.accent1[6], ALPHA_MASK))
+        return intArrayOf(
+            setAlphaComponent(this.accent1[2], ALPHA_MASK),
+            setAlphaComponent(this.accent1[2], ALPHA_MASK),
+            ColorStateList.valueOf(this.accent3[6]).withLStar(85f).colors[0],
+            setAlphaComponent(this.accent1[6], ALPHA_MASK)
+        )
     }
 
     /**
-     * Returns the color for the dark theme version of the preview of a ColorScheme
-     * based on this order:
-     * |-------|
-     * | 0 | 1 |
-     * |---+---|
-     * | 2 | 3 |
-     * |-------|
+     * Returns the color for the dark theme version of the preview of a ColorScheme based on this
+     * order: |-------| | 0 | 1 | |---+---| | 2 | 3 | |-------|
      */
     @ColorInt
     private fun ColorScheme.getDarkColorPreview(): IntArray {
-        return intArrayOf(setAlphaComponent(this.accent1[2], ALPHA_MASK),
-                setAlphaComponent(this.accent1[2], ALPHA_MASK),
-                ColorStateList.valueOf(this.accent3[6]).withLStar(85f).colors[0],
-                setAlphaComponent(this.accent1[6], ALPHA_MASK))
+        return intArrayOf(
+            setAlphaComponent(this.accent1[2], ALPHA_MASK),
+            setAlphaComponent(this.accent1[2], ALPHA_MASK),
+            ColorStateList.valueOf(this.accent3[6]).withLStar(85f).colors[0],
+            setAlphaComponent(this.accent1[6], ALPHA_MASK)
+        )
     }
 
     private fun ColorScheme.getPresetColorPreview(seed: Int): IntArray {
-        return when(this.style) {
+        return when (this.style) {
             Style.FRUIT_SALAD -> intArrayOf(seed, this.accent1[2])
             Style.TONAL_SPOT -> intArrayOf(this.accentColor, this.accentColor)
+            Style.MONOCHROMATIC ->
+                intArrayOf(
+                    setAlphaComponent(0x000000, 255),
+                    setAlphaComponent(0xFFFFFF, 255),
+                )
             else -> intArrayOf(this.accent1[2], this.accent1[2])
         }
     }
 
-    private suspend fun loadPreset() = withContext(Dispatchers.IO) {
-        val extractor = ColorBundlePreviewExtractor(mContext)
-        val bundles: MutableList<ColorOption> = ArrayList()
+    private suspend fun loadPreset() =
+        withContext(Dispatchers.IO) {
+            val extractor = ColorBundlePreviewExtractor(mContext)
+            val bundles: MutableList<ColorOption> = ArrayList()
 
-        val bundleNames = getItemsFromStub(COLOR_BUNDLES_ARRAY_NAME)
-        // Color option index value starts from 1.
-        var index = 1
-        val maxPresetColors = if (themeStyleEnabled) bundleNames.size else MAX_PRESET_COLORS
-        for (bundleName in bundleNames.take(maxPresetColors)) {
-            val builder = ColorBundle.Builder()
-            builder.title = getItemStringFromStub(COLOR_BUNDLE_NAME_PREFIX, bundleName)
-            builder.setIndex(index)
-            val colorFromStub = getItemColorFromStub(COLOR_BUNDLE_MAIN_COLOR_PREFIX, bundleName)
-            extractor.addPrimaryColor(builder, colorFromStub)
-            extractor.addSecondaryColor(builder, colorFromStub)
-            if (themeStyleEnabled) {
-                val styleName = try {
-                    getItemStringFromStub(COLOR_BUNDLE_STYLE_PREFIX, bundleName)
-                } catch (e: Resources.NotFoundException) {
-                    null
-                }
-                extractor.addColorStyle(builder, styleName)
-                val style = try {
-                    if (styleName != null) Style.valueOf(styleName) else Style.TONAL_SPOT
-                } catch (e: IllegalArgumentException) {
-                    Style.TONAL_SPOT
+            val bundleNames = getItemsFromStub(COLOR_BUNDLES_ARRAY_NAME)
+            // Color option index value starts from 1.
+            var index = 1
+            val maxPresetColors = if (themeStyleEnabled) bundleNames.size else MAX_PRESET_COLORS
+            for (bundleName in bundleNames.take(maxPresetColors)) {
+                val builder = ColorBundle.Builder()
+                builder.title = getItemStringFromStub(COLOR_BUNDLE_NAME_PREFIX, bundleName)
+                builder.setIndex(index)
+                val colorFromStub = getItemColorFromStub(COLOR_BUNDLE_MAIN_COLOR_PREFIX, bundleName)
+                extractor.addPrimaryColor(builder, colorFromStub)
+                extractor.addSecondaryColor(builder, colorFromStub)
+                if (themeStyleEnabled) {
+                    val styleName =
+                        try {
+                            getItemStringFromStub(COLOR_BUNDLE_STYLE_PREFIX, bundleName)
+                        } catch (e: Resources.NotFoundException) {
+                            null
+                        }
+                    extractor.addColorStyle(builder, styleName)
+                    val style =
+                        try {
+                            if (styleName != null) Style.valueOf(styleName) else Style.TONAL_SPOT
+                        } catch (e: IllegalArgumentException) {
+                            Style.TONAL_SPOT
+                        }
+
+                    if (style == Style.MONOCHROMATIC && !Flags.isMonochromaticFlagEnabled) {
+                        continue
+                    }
+
+                    val darkColors =
+                        ColorScheme(colorFromStub, true, style).getPresetColorPreview(colorFromStub)
+                    val lightColors =
+                        ColorScheme(colorFromStub, false, style)
+                            .getPresetColorPreview(colorFromStub)
+                    builder.setColorPrimaryDark(darkColors[0]).setColorSecondaryDark(darkColors[1])
+                    builder
+                        .setColorPrimaryLight(lightColors[0])
+                        .setColorSecondaryLight(lightColors[1])
                 }
 
-                val darkColors = ColorScheme(colorFromStub, true, style)
-                        .getPresetColorPreview(colorFromStub)
-                val lightColors = ColorScheme(colorFromStub, false, style)
-                        .getPresetColorPreview(colorFromStub)
-                builder.setColorPrimaryDark(darkColors[0]).setColorSecondaryDark(darkColors[1])
-                builder.setColorPrimaryLight(lightColors[0]).setColorSecondaryLight(lightColors[1])
+                bundles.add(builder.build(mContext))
+                index++
             }
 
-            extractor.addAndroidIconOverlay(builder)
-            bundles.add(builder.build(mContext))
-            index++
+            colorBundles = bundles
         }
-
-        colorBundles = bundles
-    }
 }
diff --git a/src/com/android/customization/model/color/ColorSeedOption.java b/src/com/android/customization/model/color/ColorSeedOption.java
index 7bddcb0..53d3954 100644
--- a/src/com/android/customization/model/color/ColorSeedOption.java
+++ b/src/com/android/customization/model/color/ColorSeedOption.java
@@ -71,13 +71,9 @@
         Resources res = view.getContext().getResources();
         @ColorInt int[] colors = mPreviewInfo.resolveColors(res);
 
-        int padding = view.isActivated()
-                ? res.getDimensionPixelSize(R.dimen.color_seed_option_tile_padding_selected)
-                : res.getDimensionPixelSize(R.dimen.color_seed_option_tile_padding);
         for (int i = 0; i < mPreviewColorIds.length; i++) {
             ImageView colorPreviewImageView = view.findViewById(mPreviewColorIds[i]);
             colorPreviewImageView.getDrawable().setColorFilter(colors[i], Mode.SRC);
-            colorPreviewImageView.setPadding(padding, padding, padding, padding);
         }
 
         view.setContentDescription(getContentDescription(view.getContext()));
diff --git a/src/com/android/customization/model/color/ColorUtils.kt b/src/com/android/customization/model/color/ColorUtils.kt
index f07ff31..9d925e1 100644
--- a/src/com/android/customization/model/color/ColorUtils.kt
+++ b/src/com/android/customization/model/color/ColorUtils.kt
@@ -22,18 +22,14 @@
 import android.util.Log
 import androidx.annotation.ColorInt
 
-/**
- * Utility to wrap Monet's color extraction
- */
+/** Utility to wrap Monet's color extraction */
 object ColorUtils {
     private const val TAG = "ColorUtils"
     private const val MONET_FLAG = "flag_monet"
     private var sSysuiRes: Resources? = null
     private var sFlagId = 0
 
-    /**
-     * Returns true if color extraction is enabled in systemui.
-     */
+    /** Returns true if color extraction is enabled in systemui. */
     @JvmStatic
     fun isMonetEnabled(context: Context): Boolean {
         var monetEnabled = SystemProperties.getBoolean("persist.systemui.flag_monet", false)
@@ -41,8 +37,11 @@
             if (sSysuiRes == null) {
                 try {
                     val pm = context.packageManager
-                    val sysUIInfo = pm.getApplicationInfo("com.android.systemui",
-                            PackageManager.GET_META_DATA or PackageManager.MATCH_SYSTEM_ONLY)
+                    val sysUIInfo =
+                        pm.getApplicationInfo(
+                            "com.android.systemui",
+                            PackageManager.GET_META_DATA or PackageManager.MATCH_SYSTEM_ONLY
+                        )
                     if (sysUIInfo != null) {
                         sSysuiRes = pm.getResourcesForApplication(sysUIInfo)
                     }
@@ -51,8 +50,9 @@
                 }
             }
             if (sFlagId == 0) {
-                sFlagId = if (sSysuiRes == null) 0 else sSysuiRes!!.getIdentifier(
-                        MONET_FLAG, "bool", "com.android.systemui")
+                sFlagId =
+                    if (sSysuiRes == null) 0
+                    else sSysuiRes!!.getIdentifier(MONET_FLAG, "bool", "com.android.systemui")
             }
             if (sFlagId > 0) {
                 monetEnabled = sSysuiRes!!.getBoolean(sFlagId)
@@ -65,4 +65,4 @@
     fun toColorString(@ColorInt color: Int): String {
         return String.format("%06X", 0xFFFFFF and color)
     }
-}
\ No newline at end of file
+}
diff --git a/src/com/android/customization/module/CustomizationInjector.java b/src/com/android/customization/module/CustomizationInjector.java
index 85853de..2cc1245 100644
--- a/src/com/android/customization/module/CustomizationInjector.java
+++ b/src/com/android/customization/module/CustomizationInjector.java
@@ -22,6 +22,7 @@
 import com.android.customization.model.theme.OverlayManagerCompat;
 import com.android.customization.model.theme.ThemeBundleProvider;
 import com.android.customization.model.theme.ThemeManager;
+import com.android.customization.picker.quickaffordance.domain.interactor.KeyguardQuickAffordancePickerInteractor;
 import com.android.wallpaper.module.Injector;
 
 public interface CustomizationInjector extends Injector {
@@ -30,4 +31,11 @@
 
     ThemeManager getThemeManager(ThemeBundleProvider provider, FragmentActivity activity,
             OverlayManagerCompat overlayManagerCompat, ThemesUserEventLogger logger);
+
+
+    /**
+     * Get {@link KeyguardQuickAffordancePickerInteractor}
+     */
+    KeyguardQuickAffordancePickerInteractor getKeyguardQuickAffordancePickerInteractor(
+            Context context);
 }
diff --git a/src/com/android/customization/module/DefaultCustomizationInjector.java b/src/com/android/customization/module/DefaultCustomizationInjector.java
deleted file mode 100644
index 220c406..0000000
--- a/src/com/android/customization/module/DefaultCustomizationInjector.java
+++ /dev/null
@@ -1,149 +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.customization.module;
-
-import android.content.Context;
-import android.content.Intent;
-import android.net.Uri;
-
-import androidx.fragment.app.Fragment;
-import androidx.fragment.app.FragmentActivity;
-
-import com.android.customization.model.theme.OverlayManagerCompat;
-import com.android.customization.model.theme.ThemeBundleProvider;
-import com.android.customization.model.theme.ThemeManager;
-import com.android.wallpaper.model.CategoryProvider;
-import com.android.wallpaper.model.WallpaperInfo;
-import com.android.wallpaper.module.BaseWallpaperInjector;
-import com.android.wallpaper.module.CustomizationSections;
-import com.android.wallpaper.module.DefaultCategoryProvider;
-import com.android.wallpaper.module.LoggingOptInStatusProvider;
-import com.android.wallpaper.module.WallpaperPreferences;
-import com.android.wallpaper.module.WallpaperRotationRefresher;
-import com.android.wallpaper.monitor.PerformanceMonitor;
-import com.android.wallpaper.picker.CustomizationPickerActivity;
-import com.android.wallpaper.picker.PreviewFragment;
-
-public class DefaultCustomizationInjector extends BaseWallpaperInjector
-        implements CustomizationInjector {
-    private CategoryProvider mCategoryProvider;
-    private ThemesUserEventLogger mUserEventLogger;
-    private WallpaperRotationRefresher mWallpaperRotationRefresher;
-    private PerformanceMonitor mPerformanceMonitor;
-    private WallpaperPreferences mPrefs;
-    private CustomizationSections mCustomizationSections;
-
-    @Override
-    public synchronized WallpaperPreferences getPreferences(Context context) {
-        if (mPrefs == null) {
-            mPrefs = new DefaultCustomizationPreferences(context.getApplicationContext());
-        }
-        return mPrefs;
-    }
-
-    @Override
-    public CustomizationPreferences getCustomizationPreferences(Context context) {
-        return (CustomizationPreferences) getPreferences(context);
-    }
-
-    @Override
-    public synchronized CategoryProvider getCategoryProvider(Context context) {
-        if (mCategoryProvider == null) {
-            mCategoryProvider = new DefaultCategoryProvider(context.getApplicationContext());
-        }
-        return mCategoryProvider;
-    }
-
-    @Override
-    public synchronized ThemesUserEventLogger getUserEventLogger(Context context) {
-        if (mUserEventLogger == null) {
-            mUserEventLogger = new StatsLogUserEventLogger(context);
-        }
-        return mUserEventLogger;
-    }
-
-    @Override
-    public synchronized WallpaperRotationRefresher getWallpaperRotationRefresher() {
-        if (mWallpaperRotationRefresher == null) {
-            mWallpaperRotationRefresher = new WallpaperRotationRefresher() {
-                @Override
-                public void refreshWallpaper(Context context, Listener listener) {
-                    // Not implemented
-                    listener.onError();
-                }
-            };
-        }
-        return mWallpaperRotationRefresher;
-    }
-
-    @Override
-    public Fragment getPreviewFragment(
-            Context context,
-            WallpaperInfo wallpaperInfo,
-            int mode,
-            boolean viewAsHome,
-            boolean viewFullScreen,
-            boolean testingModeEnabled) {
-        return PreviewFragment.newInstance(wallpaperInfo, mode, viewAsHome, viewFullScreen,
-                testingModeEnabled);
-    }
-
-    @Override
-    public Intent getDeepLinkRedirectIntent(Context context, Uri uri) {
-        Intent intent = new Intent();
-        intent.setClass(context, CustomizationPickerActivity.class);
-        intent.setData(uri);
-        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
-        return intent;
-    }
-
-    @Override
-    public String getDownloadableIntentAction() {
-        return null;
-    }
-
-    @Override
-    public synchronized PerformanceMonitor getPerformanceMonitor() {
-        if (mPerformanceMonitor == null) {
-            mPerformanceMonitor = new PerformanceMonitor() {
-                @Override
-                public void recordFullResPreviewLoadedMemorySnapshot() {
-                    // No Op
-                }
-            };
-        }
-        return mPerformanceMonitor;
-    }
-
-    @Override
-    public synchronized LoggingOptInStatusProvider getLoggingOptInStatusProvider(Context context) {
-        return null;
-    }
-
-    @Override
-    public ThemeManager getThemeManager(ThemeBundleProvider provider, FragmentActivity activity,
-            OverlayManagerCompat overlayManagerCompat, ThemesUserEventLogger logger) {
-        return new ThemeManager(provider, activity, overlayManagerCompat, logger);
-    }
-
-    @Override
-    public CustomizationSections getCustomizationSections() {
-        if (mCustomizationSections == null) {
-            mCustomizationSections = new DefaultCustomizationSections();
-        }
-        return mCustomizationSections;
-    }
-}
diff --git a/src/com/android/customization/module/DefaultCustomizationSections.java b/src/com/android/customization/module/DefaultCustomizationSections.java
index 21f2c84..7eb8865 100644
--- a/src/com/android/customization/module/DefaultCustomizationSections.java
+++ b/src/com/android/customization/module/DefaultCustomizationSections.java
@@ -1,9 +1,9 @@
 package com.android.customization.module;
 
-import android.app.Activity;
 import android.os.Bundle;
 
 import androidx.annotation.Nullable;
+import androidx.fragment.app.FragmentActivity;
 import androidx.lifecycle.LifecycleOwner;
 
 import com.android.customization.model.color.ColorSectionController;
@@ -28,9 +28,12 @@
 public final class DefaultCustomizationSections implements CustomizationSections {
 
     @Override
-    public List<CustomizationSectionController<?>> getAllSectionControllers(Activity activity,
-            LifecycleOwner lifecycleOwner, WallpaperColorsViewModel wallpaperColorsViewModel,
-            WorkspaceViewModel workspaceViewModel, PermissionRequester permissionRequester,
+    public List<CustomizationSectionController<?>> getAllSectionControllers(
+            FragmentActivity activity,
+            LifecycleOwner lifecycleOwner,
+            WallpaperColorsViewModel wallpaperColorsViewModel,
+            WorkspaceViewModel workspaceViewModel,
+            PermissionRequester permissionRequester,
             WallpaperPreviewNavigator wallpaperPreviewNavigator,
             CustomizationSectionNavigationController sectionNavigationController,
             @Nullable Bundle savedInstanceState) {
diff --git a/src/com/android/customization/module/StatsLogUserEventLogger.java b/src/com/android/customization/module/StatsLogUserEventLogger.java
index e3e4336..605c173 100644
--- a/src/com/android/customization/module/StatsLogUserEventLogger.java
+++ b/src/com/android/customization/module/StatsLogUserEventLogger.java
@@ -177,11 +177,14 @@
     }
 
     @Override
-    public void logEffectApply(String effect, @EffectStatus int status) {
+    public void logEffectApply(String effect, @EffectStatus int status, long timeElapsedMillis,
+            int resultCode) {
         new SysUiStatsLogger()
                 .setAction(StyleEnums.WALLPAPER_EFFECT_APPLIED)
                 .setEffectPreference(status)
                 .setEffectIdHash(getIdHashCode(effect))
+                .setTimeElapsed(timeElapsedMillis)
+                .setEffectResultCode(resultCode)
                 .log();
     }
 
diff --git a/src/com/android/customization/module/SysUiStatsLogger.kt b/src/com/android/customization/module/SysUiStatsLogger.kt
index eb3bcc0..318bf1f 100644
--- a/src/com/android/customization/module/SysUiStatsLogger.kt
+++ b/src/com/android/customization/module/SysUiStatsLogger.kt
@@ -19,9 +19,7 @@
 import com.android.systemui.shared.system.SysUiStatsLog
 import com.android.systemui.shared.system.SysUiStatsLog.STYLE_UI_CHANGED
 
-/**
- * The builder for [SysUiStatsLog].
- */
+/** The builder for [SysUiStatsLog]. */
 class SysUiStatsLogger {
 
     private var atom = STYLE_UI_CHANGED
@@ -45,68 +43,84 @@
     private var firstWallpaperApplyDateSinceSetup = 0
     private var appLaunchCount = 0
     private var colorVariant = 0
+    private var timeElapsedMillis = 0L
+    private var effectResultCode = -1
 
-    fun setAction(action: Int) =
-        apply { this.action = action }
+    fun setAction(action: Int) = apply { this.action = action }
 
-    fun setColorPackageHash(color_package_hash: Int) =
-        apply { this.colorPackageHash = color_package_hash }
+    fun setColorPackageHash(color_package_hash: Int) = apply {
+        this.colorPackageHash = color_package_hash
+    }
 
-    fun setFontPackageHash(font_package_hash: Int) =
-        apply { this.fontPackageHash = font_package_hash }
+    fun setFontPackageHash(font_package_hash: Int) = apply {
+        this.fontPackageHash = font_package_hash
+    }
 
-    fun setShapePackageHash(shape_package_hash: Int) =
-        apply { this.shapePackageHash = shape_package_hash }
+    fun setShapePackageHash(shape_package_hash: Int) = apply {
+        this.shapePackageHash = shape_package_hash
+    }
 
-    fun setClockPackageHash(clock_package_hash: Int) =
-        apply { this.clockPackageHash = clock_package_hash }
+    fun setClockPackageHash(clock_package_hash: Int) = apply {
+        this.clockPackageHash = clock_package_hash
+    }
 
-    fun setLauncherGrid(launcher_grid: Int) =
-        apply { this.launcherGrid = launcher_grid }
+    fun setLauncherGrid(launcher_grid: Int) = apply { this.launcherGrid = launcher_grid }
 
-    fun setWallpaperCategoryHash(wallpaper_category_hash: Int) =
-        apply { this.wallpaperCategoryHash = wallpaper_category_hash }
+    fun setWallpaperCategoryHash(wallpaper_category_hash: Int) = apply {
+        this.wallpaperCategoryHash = wallpaper_category_hash
+    }
 
-    fun setWallpaperIdHash(wallpaper_id_hash: Int) =
-        apply { this.wallpaperIdHash = wallpaper_id_hash }
+    fun setWallpaperIdHash(wallpaper_id_hash: Int) = apply {
+        this.wallpaperIdHash = wallpaper_id_hash
+    }
 
-    fun setColorPreference(color_preference: Int) =
-        apply { this.colorPreference = color_preference }
+    fun setColorPreference(color_preference: Int) = apply {
+        this.colorPreference = color_preference
+    }
 
-    fun setLocationPreference(location_preference: Int) =
-        apply { this.locationPreference = location_preference }
+    fun setLocationPreference(location_preference: Int) = apply {
+        this.locationPreference = location_preference
+    }
 
-    fun setDatePreference(date_preference: Int) =
-        apply { this.datePreference = date_preference }
+    fun setDatePreference(date_preference: Int) = apply { this.datePreference = date_preference }
 
-    fun setLaunchedPreference(launched_preference: Int) =
-        apply { this.launchedPreference = launched_preference }
+    fun setLaunchedPreference(launched_preference: Int) = apply {
+        this.launchedPreference = launched_preference
+    }
 
-    fun setEffectPreference(effect_preference: Int) =
-        apply { this.effectPreference = effect_preference }
+    fun setEffectPreference(effect_preference: Int) = apply {
+        this.effectPreference = effect_preference
+    }
 
-    fun setEffectIdHash(effect_id_hash: Int) =
-        apply { this.effectIdHash = effect_id_hash }
+    fun setEffectIdHash(effect_id_hash: Int) = apply { this.effectIdHash = effect_id_hash }
 
-    fun setLockWallpaperCategoryHash(lock_wallpaper_category_hash: Int) =
-        apply { this.lockWallpaperCategoryHash = lock_wallpaper_category_hash }
+    fun setLockWallpaperCategoryHash(lock_wallpaper_category_hash: Int) = apply {
+        this.lockWallpaperCategoryHash = lock_wallpaper_category_hash
+    }
 
-    fun setLockWallpaperIdHash(lock_wallpaper_id_hash: Int) =
-        apply { this.lockWallpaperIdHash = lock_wallpaper_id_hash }
+    fun setLockWallpaperIdHash(lock_wallpaper_id_hash: Int) = apply {
+        this.lockWallpaperIdHash = lock_wallpaper_id_hash
+    }
 
-    fun setFirstLaunchDateSinceSetup(first_launch_date_since_setup: Int) =
-        apply { this.firstLaunchDateSinceSetup = first_launch_date_since_setup }
+    fun setFirstLaunchDateSinceSetup(first_launch_date_since_setup: Int) = apply {
+        this.firstLaunchDateSinceSetup = first_launch_date_since_setup
+    }
 
-    fun setFirstWallpaperApplyDateSinceSetup(first_wallpaper_apply_date_since_setup: Int) =
-        apply {
-            this.firstWallpaperApplyDateSinceSetup = first_wallpaper_apply_date_since_setup
-        }
+    fun setFirstWallpaperApplyDateSinceSetup(first_wallpaper_apply_date_since_setup: Int) = apply {
+        this.firstWallpaperApplyDateSinceSetup = first_wallpaper_apply_date_since_setup
+    }
 
-    fun setAppLaunchCount(app_launch_count: Int) =
-        apply { this.appLaunchCount = app_launch_count }
+    fun setAppLaunchCount(app_launch_count: Int) = apply { this.appLaunchCount = app_launch_count }
 
-    fun setColorVariant(color_variant: Int) =
-        apply { this.colorVariant = color_variant }
+    fun setColorVariant(color_variant: Int) = apply { this.colorVariant = color_variant }
+
+    fun setTimeElapsed(time_elapsed_millis: Long) = apply {
+      this.timeElapsedMillis = time_elapsed_millis
+    }
+
+    fun setEffectResultCode(effect_result_code: Int) = apply {
+        this.effectResultCode = effect_result_code
+    }
 
     fun log() {
         SysUiStatsLog.write(
@@ -130,7 +144,9 @@
             firstLaunchDateSinceSetup,
             firstWallpaperApplyDateSinceSetup,
             appLaunchCount,
-            colorVariant
+            colorVariant,
+            timeElapsedMillis,
+            effectResultCode,
         )
     }
-}
\ No newline at end of file
+}
diff --git a/src/com/android/customization/module/ThemePickerFragmentFactory.kt b/src/com/android/customization/module/ThemePickerFragmentFactory.kt
new file mode 100644
index 0000000..75c3403
--- /dev/null
+++ b/src/com/android/customization/module/ThemePickerFragmentFactory.kt
@@ -0,0 +1,33 @@
+/*
+ * 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.customization.module
+
+import androidx.fragment.app.Fragment
+import com.android.customization.picker.quickaffordance.ui.fragment.KeyguardQuickAffordancePickerFragment
+import com.android.wallpaper.module.FragmentFactory
+
+class ThemePickerFragmentFactory : FragmentFactory {
+
+    override fun create(id: String): Fragment? {
+        return when (id) {
+            KeyguardQuickAffordancePickerFragment.DESTINATION_ID ->
+                KeyguardQuickAffordancePickerFragment.newInstance()
+            else -> null
+        }
+    }
+}
diff --git a/src/com/android/customization/module/ThemePickerInjector.java b/src/com/android/customization/module/ThemePickerInjector.java
new file mode 100644
index 0000000..9a304e9
--- /dev/null
+++ b/src/com/android/customization/module/ThemePickerInjector.java
@@ -0,0 +1,173 @@
+/*
+ * 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.customization.module;
+
+import static com.android.wallpaper.picker.PreviewFragment.ARG_FULL_SCREEN;
+import static com.android.wallpaper.picker.PreviewFragment.ARG_PREVIEW_MODE;
+import static com.android.wallpaper.picker.PreviewFragment.ARG_TESTING_MODE_ENABLED;
+import static com.android.wallpaper.picker.PreviewFragment.ARG_VIEW_AS_HOME;
+import static com.android.wallpaper.picker.PreviewFragment.ARG_WALLPAPER;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Bundle;
+
+import androidx.fragment.app.Fragment;
+import androidx.fragment.app.FragmentActivity;
+
+import com.android.customization.model.theme.OverlayManagerCompat;
+import com.android.customization.model.theme.ThemeBundleProvider;
+import com.android.customization.model.theme.ThemeManager;
+import com.android.customization.picker.quickaffordance.data.repository.KeyguardQuickAffordancePickerRepository;
+import com.android.customization.picker.quickaffordance.domain.interactor.KeyguardQuickAffordancePickerInteractor;
+import com.android.customization.picker.quickaffordance.ui.viewmodel.KeyguardQuickAffordancePickerViewModel;
+import com.android.systemui.shared.quickaffordance.data.content.KeyguardQuickAffordanceProviderClient;
+import com.android.systemui.shared.quickaffordance.data.content.KeyguardQuickAffordanceProviderClientImpl;
+import com.android.wallpaper.model.LiveWallpaperInfo;
+import com.android.wallpaper.model.WallpaperInfo;
+import com.android.wallpaper.module.CustomizationSections;
+import com.android.wallpaper.module.FragmentFactory;
+import com.android.wallpaper.module.WallpaperPicker2Injector;
+import com.android.wallpaper.module.WallpaperPreferences;
+import com.android.wallpaper.picker.CustomizationPickerActivity;
+import com.android.wallpaper.picker.ImagePreviewFragment;
+import com.android.wallpaper.picker.LivePreviewFragment;
+import com.android.wallpaper.picker.PreviewFragment;
+
+import kotlinx.coroutines.Dispatchers;
+
+/**
+ * A concrete, real implementation of the dependency provider.
+ */
+public class ThemePickerInjector extends WallpaperPicker2Injector
+        implements CustomizationInjector {
+    private CustomizationSections mCustomizationSections;
+    private ThemesUserEventLogger mUserEventLogger;
+    private WallpaperPreferences mPrefs;
+    private KeyguardQuickAffordancePickerInteractor mKeyguardQuickAffordancePickerInteractor;
+    private KeyguardQuickAffordancePickerViewModel.Factory
+            mKeyguardQuickAffordancePickerViewModelFactory;
+    private FragmentFactory mFragmentFactory;
+
+    @Override
+    public CustomizationSections getCustomizationSections(Activity activity) {
+        if (mCustomizationSections == null) {
+            mCustomizationSections = new DefaultCustomizationSections();
+        }
+        return mCustomizationSections;
+    }
+
+    @Override
+    public Intent getDeepLinkRedirectIntent(Context context, Uri uri) {
+        Intent intent = new Intent();
+        intent.setClass(context, CustomizationPickerActivity.class);
+        intent.setData(uri);
+        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
+        return intent;
+    }
+
+    @Override
+    public String getDownloadableIntentAction() {
+        return null;
+    }
+
+    @Override
+    public Fragment getPreviewFragment(
+            Context context,
+            WallpaperInfo wallpaperInfo,
+            int mode,
+            boolean viewAsHome,
+            boolean viewFullScreen,
+            boolean testingModeEnabled) {
+        Bundle args = new Bundle();
+        args.putParcelable(ARG_WALLPAPER, wallpaperInfo);
+        args.putInt(ARG_PREVIEW_MODE, mode);
+        args.putBoolean(ARG_VIEW_AS_HOME, viewAsHome);
+        args.putBoolean(ARG_FULL_SCREEN, viewFullScreen);
+        args.putBoolean(ARG_TESTING_MODE_ENABLED, testingModeEnabled);
+        PreviewFragment fragment = wallpaperInfo instanceof LiveWallpaperInfo
+                ? new LivePreviewFragment() : new ImagePreviewFragment();
+        fragment.setArguments(args);
+        return fragment;
+    }
+
+    @Override
+    public synchronized ThemesUserEventLogger getUserEventLogger(Context context) {
+        if (mUserEventLogger == null) {
+            mUserEventLogger = new StatsLogUserEventLogger(context);
+        }
+        return mUserEventLogger;
+    }
+
+    @Override
+    public synchronized WallpaperPreferences getPreferences(Context context) {
+        if (mPrefs == null) {
+            mPrefs = new DefaultCustomizationPreferences(context.getApplicationContext());
+        }
+        return mPrefs;
+    }
+
+    //
+    // Functions from {@link CustomizationInjector}
+    //
+    @Override
+    public CustomizationPreferences getCustomizationPreferences(Context context) {
+        return (CustomizationPreferences) getPreferences(context);
+    }
+
+    @Override
+    public ThemeManager getThemeManager(ThemeBundleProvider provider, FragmentActivity activity,
+            OverlayManagerCompat overlayManagerCompat, ThemesUserEventLogger logger) {
+        return new ThemeManager(provider, activity, overlayManagerCompat, logger);
+    }
+
+    @Override
+    public KeyguardQuickAffordancePickerInteractor getKeyguardQuickAffordancePickerInteractor(
+            Context context) {
+        if (mKeyguardQuickAffordancePickerInteractor == null) {
+            final KeyguardQuickAffordanceProviderClient client =
+                    new KeyguardQuickAffordanceProviderClientImpl(context, Dispatchers.getIO());
+            mKeyguardQuickAffordancePickerInteractor = new KeyguardQuickAffordancePickerInteractor(
+                    new KeyguardQuickAffordancePickerRepository(client, Dispatchers.getIO()),
+                    client);
+        }
+        return mKeyguardQuickAffordancePickerInteractor;
+    }
+
+    /**
+     * Returns a {@link KeyguardQuickAffordancePickerViewModel.Factory}.
+     */
+    public KeyguardQuickAffordancePickerViewModel.Factory
+            getKeyguardQuickAffordancePickerViewModelFactory(Context context) {
+        if (mKeyguardQuickAffordancePickerViewModelFactory == null) {
+            mKeyguardQuickAffordancePickerViewModelFactory =
+                    new KeyguardQuickAffordancePickerViewModel.Factory(
+                            context,
+                            getKeyguardQuickAffordancePickerInteractor(context));
+        }
+        return mKeyguardQuickAffordancePickerViewModelFactory;
+    }
+
+    @Override
+    public FragmentFactory getFragmentFactory() {
+        if (mFragmentFactory == null) {
+            mFragmentFactory = new ThemePickerFragmentFactory();
+        }
+        return mFragmentFactory;
+    }
+}
diff --git a/src/com/android/customization/picker/CustomizationPickerApplication.java b/src/com/android/customization/picker/CustomizationPickerApplication.java
index 79d075a..178cfbf 100644
--- a/src/com/android/customization/picker/CustomizationPickerApplication.java
+++ b/src/com/android/customization/picker/CustomizationPickerApplication.java
@@ -17,7 +17,7 @@
 
 import android.app.Application;
 
-import com.android.customization.module.DefaultCustomizationInjector;
+import com.android.customization.module.ThemePickerInjector;
 import com.android.wallpaper.module.InjectorProvider;
 
 public class CustomizationPickerApplication extends Application {
@@ -26,6 +26,6 @@
         super.onCreate();
 
         // Initialize the injector.
-        InjectorProvider.setInjector(new DefaultCustomizationInjector());
+        InjectorProvider.setInjector(new ThemePickerInjector());
     }
 }
diff --git a/src/com/android/customization/picker/clock/ClockCustomDemoFragment.kt b/src/com/android/customization/picker/clock/ClockCustomDemoFragment.kt
new file mode 100644
index 0000000..8648dca
--- /dev/null
+++ b/src/com/android/customization/picker/clock/ClockCustomDemoFragment.kt
@@ -0,0 +1,191 @@
+package com.android.customization.picker.clock
+
+import android.app.NotificationManager
+import android.content.ComponentName
+import android.content.Context
+import android.os.Bundle
+import android.os.Handler
+import android.os.UserHandle
+import android.view.ContextThemeWrapper
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.view.ViewGroup.LayoutParams.MATCH_PARENT
+import android.view.ViewGroup.LayoutParams.WRAP_CONTENT
+import android.widget.FrameLayout
+import android.widget.TextView
+import androidx.core.view.setPadding
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.RecyclerView
+import com.android.internal.annotations.VisibleForTesting
+import com.android.systemui.plugins.ClockMetadata
+import com.android.systemui.plugins.ClockProviderPlugin
+import com.android.systemui.plugins.Plugin
+import com.android.systemui.plugins.PluginListener
+import com.android.systemui.plugins.PluginManager
+import com.android.systemui.shared.clocks.ClockRegistry
+import com.android.systemui.shared.clocks.DefaultClockProvider
+import com.android.systemui.shared.plugins.PluginActionManager
+import com.android.systemui.shared.plugins.PluginEnabler
+import com.android.systemui.shared.plugins.PluginEnabler.ENABLED
+import com.android.systemui.shared.plugins.PluginInstance
+import com.android.systemui.shared.plugins.PluginManagerImpl
+import com.android.systemui.shared.plugins.PluginPrefs
+import com.android.systemui.shared.system.UncaughtExceptionPreHandlerManager_Factory
+import com.android.wallpaper.R
+import com.android.wallpaper.picker.AppbarFragment
+import java.util.concurrent.Executors
+
+private val TAG = ClockCustomDemoFragment::class.simpleName
+
+class ClockCustomDemoFragment : AppbarFragment() {
+    @VisibleForTesting lateinit var clockRegistry: ClockRegistry
+    val isDebugDevice = true
+    val privilegedPlugins = listOf<String>()
+    val action = ClockProviderPlugin.ACTION
+    lateinit var view: ViewGroup
+    @VisibleForTesting lateinit var recyclerView: RecyclerView
+    lateinit var pluginManager: PluginManager
+    @VisibleForTesting
+    val pluginListener =
+        object : PluginListener<ClockProviderPlugin> {
+            override fun onPluginConnected(plugin: ClockProviderPlugin, context: Context) {
+                val listInUse = clockRegistry.getClocks().filter { "NOT_IN_USE" !in it.clockId }
+                recyclerView.adapter = ClockRecyclerAdapter(listInUse, context, clockRegistry)
+            }
+        }
+
+    override fun onAttach(context: Context) {
+        super.onAttach(context)
+        val defaultClockProvider =
+            DefaultClockProvider(context, LayoutInflater.from(context), context.resources)
+        pluginManager = createPluginManager(context)
+        clockRegistry =
+            ClockRegistry(
+                context,
+                pluginManager,
+                Handler.getMain(),
+                isEnabled = true,
+                userHandle = UserHandle.USER_OWNER,
+                defaultClockProvider
+            )
+        pluginManager.addPluginListener(pluginListener, ClockProviderPlugin::class.java, true)
+    }
+
+    override fun onCreateView(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View {
+        val view = inflater.inflate(R.layout.fragment_clock_custom_picker_demo, container, false)
+        setUpToolbar(view)
+        return view
+    }
+
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        recyclerView = view.requireViewById(R.id.clock_preview_card_list_demo)
+        recyclerView.layoutManager = LinearLayoutManager(context, RecyclerView.VERTICAL, false)
+        super.onViewCreated(view, savedInstanceState)
+    }
+
+    override fun getDefaultTitle(): CharSequence {
+        return getString(R.string.clock_title)
+    }
+
+    private fun createPluginManager(context: Context): PluginManager {
+        val instanceFactory =
+            PluginInstance.Factory(
+                this::class.java.classLoader,
+                PluginInstance.InstanceFactory<Plugin>(),
+                PluginInstance.VersionChecker(),
+                privilegedPlugins,
+                isDebugDevice
+            )
+
+        /*
+         * let SystemUI handle plugin, in this class assume plugins are enabled
+         */
+        val pluginEnabler =
+            object : PluginEnabler {
+                override fun setEnabled(component: ComponentName) {}
+
+                override fun setDisabled(
+                    component: ComponentName,
+                    @PluginEnabler.DisableReason reason: Int
+                ) {}
+
+                override fun isEnabled(component: ComponentName): Boolean {
+                    return true
+                }
+
+                @PluginEnabler.DisableReason
+                override fun getDisableReason(componentName: ComponentName): Int {
+                    return ENABLED
+                }
+            }
+
+        val pluginActionManager =
+            PluginActionManager.Factory(
+                context,
+                context.packageManager,
+                context.mainExecutor,
+                Executors.newSingleThreadExecutor(),
+                context.getSystemService(NotificationManager::class.java),
+                pluginEnabler,
+                privilegedPlugins,
+                instanceFactory
+            )
+        return PluginManagerImpl(
+            context,
+            pluginActionManager,
+            isDebugDevice,
+            uncaughtExceptionPreHandlerManager,
+            pluginEnabler,
+            PluginPrefs(context),
+            listOf()
+        )
+    }
+
+    companion object {
+        private val uncaughtExceptionPreHandlerManager =
+            UncaughtExceptionPreHandlerManager_Factory.create().get()
+    }
+
+    internal class ClockRecyclerAdapter(
+        val list: List<ClockMetadata>,
+        val context: Context,
+        val clockRegistry: ClockRegistry
+    ) : RecyclerView.Adapter<ClockRecyclerAdapter.ViewHolder>() {
+        class ViewHolder(val view: View, val textView: TextView, val onItemClicked: (Int) -> Unit) :
+            RecyclerView.ViewHolder(view) {
+            init {
+                itemView.setOnClickListener { onItemClicked(absoluteAdapterPosition) }
+            }
+        }
+
+        override fun onCreateViewHolder(viewGroup: ViewGroup, viewType: Int): ViewHolder {
+            val rootView = FrameLayout(viewGroup.context)
+            val textView =
+                TextView(ContextThemeWrapper(viewGroup.context, R.style.SectionTitleTextStyle))
+            textView.setPadding(ITEM_PADDING)
+            rootView.addView(textView)
+            val lp = RecyclerView.LayoutParams(MATCH_PARENT, WRAP_CONTENT)
+            rootView.setLayoutParams(lp)
+            return ViewHolder(
+                rootView,
+                textView,
+                { clockRegistry.currentClockId = list[it].clockId }
+            )
+        }
+
+        override fun onBindViewHolder(viewHolder: ViewHolder, position: Int) {
+            viewHolder.textView.text = list[position].name
+        }
+
+        override fun getItemCount() = list.size
+
+        companion object {
+            val ITEM_PADDING = 40
+        }
+    }
+}
diff --git a/src/com/android/customization/picker/clock/ClockSectionView.kt b/src/com/android/customization/picker/clock/ClockSectionView.kt
index c043209..fac975a 100644
--- a/src/com/android/customization/picker/clock/ClockSectionView.kt
+++ b/src/com/android/customization/picker/clock/ClockSectionView.kt
@@ -19,5 +19,5 @@
 import android.util.AttributeSet
 import com.android.wallpaper.picker.SectionView
 
-/** The [SectionView] for app clock.  */
-class ClockSectionView(context: Context?, attrs: AttributeSet?) : SectionView(context, attrs)
\ No newline at end of file
+/** The [SectionView] for app clock. */
+class ClockSectionView(context: Context?, attrs: AttributeSet?) : SectionView(context, attrs)
diff --git a/src/com/android/customization/picker/grid/GridFragment.java b/src/com/android/customization/picker/grid/GridFragment.java
index c4029d6..d60ebca 100644
--- a/src/com/android/customization/picker/grid/GridFragment.java
+++ b/src/com/android/customization/picker/grid/GridFragment.java
@@ -160,7 +160,7 @@
                 getActivity(), view.findViewById(R.id.wallpaper_preview_image), wallpaperSurface);
         // Loads current Wallpaper.
         CurrentWallpaperInfoFactory factory = InjectorProvider.getInjector()
-                .getCurrentWallpaperFactory(getContext().getApplicationContext());
+                .getCurrentWallpaperInfoFactory(getContext().getApplicationContext());
         factory.createCurrentWallpaperInfos((homeWallpaper, lockWallpaper, presentationMode) -> {
             mHomeWallpaper = homeWallpaper;
             wallpaperPreviewer.setWallpaper(mHomeWallpaper, /* listener= */ null);
diff --git a/src/com/android/customization/picker/quickaffordance/data/repository/KeyguardQuickAffordancePickerRepository.kt b/src/com/android/customization/picker/quickaffordance/data/repository/KeyguardQuickAffordancePickerRepository.kt
new file mode 100644
index 0000000..5846107
--- /dev/null
+++ b/src/com/android/customization/picker/quickaffordance/data/repository/KeyguardQuickAffordancePickerRepository.kt
@@ -0,0 +1,92 @@
+/*
+ * 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.customization.picker.quickaffordance.data.repository
+
+import com.android.customization.picker.quickaffordance.shared.model.KeyguardQuickAffordancePickerAffordanceModel as AffordanceModel
+import com.android.customization.picker.quickaffordance.shared.model.KeyguardQuickAffordancePickerSelectionModel as SelectionModel
+import com.android.customization.picker.quickaffordance.shared.model.KeyguardQuickAffordancePickerSlotModel as SlotModel
+import com.android.systemui.shared.quickaffordance.data.content.KeyguardQuickAffordanceProviderClient as Client
+import com.android.systemui.shared.quickaffordance.data.content.KeyguardQuickAffordanceProviderContract as Contract
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.withContext
+
+/**
+ * Abstracts access to application state related to functionality for selecting, picking, or setting
+ * lock screen quick affordances.
+ */
+class KeyguardQuickAffordancePickerRepository(
+    private val client: Client,
+    private val backgroundDispatcher: CoroutineDispatcher,
+) {
+    /** Whether the feature is enabled. */
+    val isFeatureEnabled: Flow<Boolean> =
+        client.observeFlags().map { flags -> flags.isFeatureEnabled() }
+
+    /** List of slots available on the device. */
+    val slots: Flow<List<SlotModel>> =
+        client.observeSlots().map { slots -> slots.map { slot -> slot.toModel() } }
+
+    /** List of all available quick affordances. */
+    val affordances: Flow<List<AffordanceModel>> =
+        client.observeAffordances().map { affordances ->
+            affordances.map { affordance -> affordance.toModel() }
+        }
+
+    /** List of slot-affordance pairs, modeling what the user has currently chosen for each slot. */
+    val selections: Flow<List<SelectionModel>> =
+        client.observeSelections().map { selections ->
+            selections.map { selection -> selection.toModel() }
+        }
+
+    suspend fun isFeatureEnabled(): Boolean {
+        return withContext(backgroundDispatcher) { client.queryFlags().isFeatureEnabled() }
+    }
+
+    private fun List<Client.Flag>.isFeatureEnabled(): Boolean {
+        return find { flag -> flag.name == Contract.FlagsTable.FLAG_NAME_FEATURE_ENABLED }?.value ==
+            true
+    }
+
+    private fun Client.Slot.toModel(): SlotModel {
+        return SlotModel(
+            id = id,
+            maxSelectedQuickAffordances = capacity,
+        )
+    }
+
+    private fun Client.Affordance.toModel(): AffordanceModel {
+        return AffordanceModel(
+            id = id,
+            name = name,
+            iconResourceId = iconResourceId,
+            isEnabled = isEnabled,
+            enablementInstructions = enablementInstructions ?: emptyList(),
+            enablementActionText = enablementActionText,
+            enablementActionComponentName = enablementActionComponentName,
+        )
+    }
+
+    private fun Client.Selection.toModel(): SelectionModel {
+        return SelectionModel(
+            slotId = slotId,
+            affordanceId = affordanceId,
+        )
+    }
+}
diff --git a/src/com/android/customization/picker/quickaffordance/domain/interactor/KeyguardQuickAffordancePickerInteractor.kt b/src/com/android/customization/picker/quickaffordance/domain/interactor/KeyguardQuickAffordancePickerInteractor.kt
new file mode 100644
index 0000000..87cedf5
--- /dev/null
+++ b/src/com/android/customization/picker/quickaffordance/domain/interactor/KeyguardQuickAffordancePickerInteractor.kt
@@ -0,0 +1,91 @@
+/*
+ * 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.customization.picker.quickaffordance.domain.interactor
+
+import android.graphics.drawable.Drawable
+import androidx.annotation.DrawableRes
+import com.android.customization.picker.quickaffordance.data.repository.KeyguardQuickAffordancePickerRepository
+import com.android.customization.picker.quickaffordance.shared.model.KeyguardQuickAffordancePickerAffordanceModel as AffordanceModel
+import com.android.customization.picker.quickaffordance.shared.model.KeyguardQuickAffordancePickerSelectionModel as SelectionModel
+import com.android.customization.picker.quickaffordance.shared.model.KeyguardQuickAffordancePickerSlotModel as SlotModel
+import com.android.systemui.shared.quickaffordance.data.content.KeyguardQuickAffordanceProviderClient as Client
+import kotlinx.coroutines.flow.Flow
+
+/**
+ * Single entry-point for all application state and business logic related to quick affordances on
+ * the lock screen.
+ */
+class KeyguardQuickAffordancePickerInteractor(
+    private val repository: KeyguardQuickAffordancePickerRepository,
+    private val client: Client,
+) {
+    /** Whether the feature is enabled. */
+    val isFeatureEnabled: Flow<Boolean> = repository.isFeatureEnabled
+
+    /** List of slots available on the device. */
+    val slots: Flow<List<SlotModel>> = repository.slots
+
+    /** List of all available quick affordances. */
+    val affordances: Flow<List<AffordanceModel>> = repository.affordances
+
+    /** List of slot-affordance pairs, modeling what the user has currently chosen for each slot. */
+    val selections: Flow<List<SelectionModel>> = repository.selections
+
+    /**
+     * Selects an affordance with the given ID for a slot with the given ID.
+     *
+     * Note that the maximum affordance per slot is automatically managed. If trying to select an
+     * affordance for a slot that's already full, the oldest affordance is removed to make room.
+     *
+     * Note that if an affordance with the given ID is already selected on the slot with the given
+     * ID, that affordance is moved to the newest position on the slot.
+     */
+    suspend fun select(slotId: String, affordanceId: String) {
+        client.insertSelection(
+            slotId = slotId,
+            affordanceId = affordanceId,
+        )
+    }
+
+    /** Unselects an affordance with the given ID from the slot with the given ID. */
+    suspend fun unselect(slotId: String, affordanceId: String) {
+        client.deleteSelection(
+            slotId = slotId,
+            affordanceId = affordanceId,
+        )
+    }
+
+    /** Unselects all affordances from the slot with the given ID. */
+    suspend fun unselectAll(slotId: String) {
+        client.deleteAllSelections(
+            slotId = slotId,
+        )
+    }
+
+    /** Returns a [Drawable] for the given resource ID, from the system UI package. */
+    suspend fun getAffordanceIcon(
+        @DrawableRes iconResourceId: Int,
+    ): Drawable {
+        return client.getAffordanceIcon(iconResourceId)
+    }
+
+    /** Returns `true` if the feature is enabled; `false` otherwise. */
+    suspend fun isFeatureEnabled(): Boolean {
+        return repository.isFeatureEnabled()
+    }
+}
diff --git a/src/com/android/customization/picker/quickaffordance/shared/model/KeyguardQuickAffordancePickerAffordanceModel.kt b/src/com/android/customization/picker/quickaffordance/shared/model/KeyguardQuickAffordancePickerAffordanceModel.kt
new file mode 100644
index 0000000..1b18af7
--- /dev/null
+++ b/src/com/android/customization/picker/quickaffordance/shared/model/KeyguardQuickAffordancePickerAffordanceModel.kt
@@ -0,0 +1,45 @@
+/*
+ * 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.customization.picker.quickaffordance.shared.model
+
+import androidx.annotation.DrawableRes
+
+/** Models a quick affordance. */
+data class KeyguardQuickAffordancePickerAffordanceModel(
+    val id: String,
+    val name: String,
+    /**
+     * The resource ID for a drawable of the icon. This is in the namespace of system UI so it
+     * should be queries from that package.
+     */
+    @DrawableRes val iconResourceId: Int,
+    /** Whether this quick affordance is enabled. */
+    val isEnabled: Boolean,
+    /** If not enabled, the list of user-visible steps to re-enable it. */
+    val enablementInstructions: List<String>,
+    /**
+     * If not enabled, an optional label for a button that takes the user to a destination where
+     * they can re-enable it.
+     */
+    val enablementActionText: String?,
+    /**
+     * If not enabled, an optional component name (package and action) for a button that takes the
+     * user to a destination where they can re-enable it.
+     */
+    val enablementActionComponentName: String?,
+)
diff --git a/src/com/android/customization/picker/quickaffordance/shared/model/KeyguardQuickAffordancePickerSelectionModel.kt b/src/com/android/customization/picker/quickaffordance/shared/model/KeyguardQuickAffordancePickerSelectionModel.kt
new file mode 100644
index 0000000..eea8b2a
--- /dev/null
+++ b/src/com/android/customization/picker/quickaffordance/shared/model/KeyguardQuickAffordancePickerSelectionModel.kt
@@ -0,0 +1,24 @@
+/*
+ * 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.customization.picker.quickaffordance.shared.model
+
+/** Models a selection of an affordance on a slot. */
+data class KeyguardQuickAffordancePickerSelectionModel(
+    val slotId: String,
+    val affordanceId: String,
+)
diff --git a/src/com/android/customization/picker/quickaffordance/shared/model/KeyguardQuickAffordancePickerSlotModel.kt b/src/com/android/customization/picker/quickaffordance/shared/model/KeyguardQuickAffordancePickerSlotModel.kt
new file mode 100644
index 0000000..7e662e0
--- /dev/null
+++ b/src/com/android/customization/picker/quickaffordance/shared/model/KeyguardQuickAffordancePickerSlotModel.kt
@@ -0,0 +1,25 @@
+/*
+ * 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.customization.picker.quickaffordance.shared.model
+
+/** Models a lock screen quick affordance slot (or position) where affordances can be displayed. */
+data class KeyguardQuickAffordancePickerSlotModel(
+    val id: String,
+    /** Maximum number of affordances allowed to be set on this slot. */
+    val maxSelectedQuickAffordances: Int,
+)
diff --git a/src/com/android/customization/picker/quickaffordance/ui/adapter/AffordancesAdapter.kt b/src/com/android/customization/picker/quickaffordance/ui/adapter/AffordancesAdapter.kt
new file mode 100644
index 0000000..b0dc350
--- /dev/null
+++ b/src/com/android/customization/picker/quickaffordance/ui/adapter/AffordancesAdapter.kt
@@ -0,0 +1,95 @@
+/*
+ * 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.customization.picker.quickaffordance.ui.adapter
+
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.widget.ImageView
+import android.widget.TextView
+import androidx.recyclerview.widget.RecyclerView
+import com.android.customization.picker.quickaffordance.ui.viewmodel.KeyguardQuickAffordanceViewModel
+import com.android.wallpaper.R
+
+/** Adapts between lock screen quick affordance items and views. */
+class AffordancesAdapter : RecyclerView.Adapter<AffordancesAdapter.ViewHolder>() {
+
+    private val items = mutableListOf<KeyguardQuickAffordanceViewModel>()
+
+    fun setItems(items: List<KeyguardQuickAffordanceViewModel>) {
+        this.items.clear()
+        this.items.addAll(items)
+        notifyDataSetChanged()
+    }
+
+    class ViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
+        val iconContainerView: View = itemView.requireViewById(R.id.icon_container)
+        val iconView: ImageView = itemView.requireViewById(R.id.icon)
+        val nameView: TextView = itemView.requireViewById(R.id.name)
+    }
+
+    override fun getItemCount(): Int {
+        return items.size
+    }
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
+        return ViewHolder(
+            LayoutInflater.from(parent.context)
+                .inflate(
+                    R.layout.keyguard_quick_affordance,
+                    parent,
+                    false,
+                )
+        )
+    }
+
+    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
+        val item = items[position]
+        holder.itemView.alpha =
+            if (item.isEnabled) {
+                ALPHA_ENABLED
+            } else {
+                ALPHA_DISABLED
+            }
+
+        holder.itemView.setOnClickListener(
+            if (item.onClicked != null) {
+                View.OnClickListener { item.onClicked.invoke() }
+            } else {
+                null
+            }
+        )
+        holder.iconContainerView.setBackgroundResource(
+            if (item.isSelected) {
+                R.drawable.keyguard_quick_affordance_icon_container_background_selected
+            } else {
+                R.drawable.keyguard_quick_affordance_icon_container_background
+            }
+        )
+        holder.iconView.isSelected = item.isSelected
+        holder.nameView.isSelected = item.isSelected
+        holder.iconView.setImageDrawable(item.icon)
+        holder.nameView.text = item.contentDescription
+        holder.nameView.isSelected = item.isSelected
+    }
+
+    companion object {
+        private const val ALPHA_ENABLED = 1f
+        private const val ALPHA_DISABLED = 0.3f
+    }
+}
diff --git a/src/com/android/customization/picker/quickaffordance/ui/adapter/SlotTabAdapter.kt b/src/com/android/customization/picker/quickaffordance/ui/adapter/SlotTabAdapter.kt
new file mode 100644
index 0000000..acafef4
--- /dev/null
+++ b/src/com/android/customization/picker/quickaffordance/ui/adapter/SlotTabAdapter.kt
@@ -0,0 +1,70 @@
+/*
+ * 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.customization.picker.quickaffordance.ui.adapter
+
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.widget.TextView
+import androidx.recyclerview.widget.RecyclerView
+import com.android.customization.picker.quickaffordance.ui.viewmodel.KeyguardQuickAffordanceSlotViewModel
+import com.android.wallpaper.R
+
+/** Adapts between lock screen quick affordance slot items and views. */
+class SlotTabAdapter : RecyclerView.Adapter<SlotTabAdapter.ViewHolder>() {
+
+    private val items = mutableListOf<KeyguardQuickAffordanceSlotViewModel>()
+
+    fun setItems(items: List<KeyguardQuickAffordanceSlotViewModel>) {
+        this.items.clear()
+        this.items.addAll(items)
+        notifyDataSetChanged()
+    }
+
+    override fun getItemCount(): Int {
+        return items.size
+    }
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
+        return ViewHolder(
+            LayoutInflater.from(parent.context)
+                .inflate(
+                    R.layout.keyguard_quick_affordance_slot_tab,
+                    parent,
+                    false,
+                )
+        )
+    }
+
+    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
+        val item = items[position]
+        holder.itemView.isSelected = item.isSelected
+        holder.textView.text = item.name
+        holder.textView.setOnClickListener(
+            if (item.onClicked != null) {
+                View.OnClickListener { item.onClicked.invoke() }
+            } else {
+                null
+            }
+        )
+    }
+
+    class ViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
+        val textView: TextView = itemView.requireViewById(R.id.text)
+    }
+}
diff --git a/src/com/android/customization/picker/quickaffordance/ui/binder/KeyguardQuickAffordancePickerBinder.kt b/src/com/android/customization/picker/quickaffordance/ui/binder/KeyguardQuickAffordancePickerBinder.kt
new file mode 100644
index 0000000..62f2e26
--- /dev/null
+++ b/src/com/android/customization/picker/quickaffordance/ui/binder/KeyguardQuickAffordancePickerBinder.kt
@@ -0,0 +1,159 @@
+/*
+ * 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.customization.picker.quickaffordance.ui.binder
+
+import android.app.AlertDialog
+import android.app.Dialog
+import android.content.Context
+import android.content.DialogInterface
+import android.graphics.Rect
+import android.view.View
+import androidx.core.view.ViewCompat
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.lifecycleScope
+import androidx.lifecycle.repeatOnLifecycle
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.RecyclerView
+import com.android.customization.picker.quickaffordance.ui.adapter.AffordancesAdapter
+import com.android.customization.picker.quickaffordance.ui.adapter.SlotTabAdapter
+import com.android.customization.picker.quickaffordance.ui.viewmodel.KeyguardQuickAffordancePickerViewModel
+import com.android.wallpaper.R
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.launch
+
+object KeyguardQuickAffordancePickerBinder {
+
+    /** Binds view with view-model for a lock screen quick affordance picker experience. */
+    @JvmStatic
+    fun bind(
+        view: View,
+        viewModel: KeyguardQuickAffordancePickerViewModel,
+        lifecycleOwner: LifecycleOwner,
+    ) {
+        val slotTabView: RecyclerView = view.requireViewById(R.id.slot_tabs)
+        val affordancesView: RecyclerView = view.requireViewById(R.id.affordances)
+
+        val slotTabAdapter = SlotTabAdapter()
+        slotTabView.adapter = slotTabAdapter
+        slotTabView.layoutManager =
+            LinearLayoutManager(view.context, RecyclerView.HORIZONTAL, false)
+        slotTabView.addItemDecoration(ItemSpacing())
+        val affordancesAdapter = AffordancesAdapter()
+        affordancesView.adapter = affordancesAdapter
+        affordancesView.layoutManager =
+            LinearLayoutManager(view.context, RecyclerView.HORIZONTAL, false)
+        affordancesView.addItemDecoration(ItemSpacing())
+
+        var dialog: Dialog? = null
+
+        lifecycleOwner.lifecycleScope.launch {
+            lifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
+                launch {
+                    viewModel.slots
+                        .map { slotById -> slotById.values }
+                        .collect { slots -> slotTabAdapter.setItems(slots.toList()) }
+                }
+
+                launch {
+                    viewModel.quickAffordances.collect { affordances ->
+                        affordancesAdapter.setItems(affordances)
+                    }
+                }
+
+                launch {
+                    viewModel.dialog.distinctUntilChanged().collect { dialogRequest ->
+                        dialog?.dismiss()
+                        dialog =
+                            if (dialogRequest != null) {
+                                showDialog(
+                                    context = view.context,
+                                    request = dialogRequest,
+                                    onDismissed = viewModel::onDialogDismissed
+                                )
+                            } else {
+                                dialog?.dismiss()
+                                null
+                            }
+                    }
+                }
+            }
+        }
+    }
+
+    private fun showDialog(
+        context: Context,
+        request: KeyguardQuickAffordancePickerViewModel.DialogViewModel,
+        onDismissed: () -> Unit,
+    ): Dialog {
+        // TODO(b/254858701): make this dialog prettier and probably use a DialogFragment.
+        return AlertDialog.Builder(context, context.themeResId)
+            .setTitle(context.getString(R.string.keyguard_affordance_enablement_dialog_title))
+            .setMessage(
+                buildString {
+                    append(request.instructionHeader)
+                    if (request.instructions.isNotEmpty()) {
+                        append("\n")
+                    }
+                    request.instructions.forEachIndexed { index, instruction ->
+                        append(instruction)
+                        if (index < request.instructions.size - 1) {
+                            append("\n")
+                        }
+                    }
+                }
+            )
+            .setOnDismissListener { onDismissed.invoke() }
+            .setPositiveButton(
+                request.actionText,
+                if (request.intent != null) {
+                    DialogInterface.OnClickListener { _, _ ->
+                        context.startActivity(request.intent)
+                    }
+                } else {
+                    DialogInterface.OnClickListener { _, _ -> onDismissed() }
+                },
+            )
+            .show()
+    }
+
+    private class ItemSpacing : RecyclerView.ItemDecoration() {
+        override fun getItemOffsets(outRect: Rect, itemPosition: Int, parent: RecyclerView) {
+            val addSpacingToStart = itemPosition > 0
+            val addSpacingToEnd = itemPosition < (parent.adapter?.itemCount ?: 0) - 1
+            val isRtl = parent.layoutManager?.layoutDirection == ViewCompat.LAYOUT_DIRECTION_RTL
+            val density = parent.context.resources.displayMetrics.density
+            if (!isRtl) {
+                outRect.left = if (addSpacingToStart) ITEM_SPACING_DP.toPx(density) else 0
+                outRect.right = if (addSpacingToEnd) ITEM_SPACING_DP.toPx(density) else 0
+            } else {
+                outRect.left = if (addSpacingToEnd) ITEM_SPACING_DP.toPx(density) else 0
+                outRect.right = if (addSpacingToStart) ITEM_SPACING_DP.toPx(density) else 0
+            }
+        }
+
+        private fun Int.toPx(density: Float): Int {
+            return (this * density).toInt()
+        }
+
+        companion object {
+            private const val ITEM_SPACING_DP = 8
+        }
+    }
+}
diff --git a/src/com/android/customization/picker/quickaffordance/ui/binder/KeyguardQuickAffordancePickerPreviewBinder.kt b/src/com/android/customization/picker/quickaffordance/ui/binder/KeyguardQuickAffordancePickerPreviewBinder.kt
new file mode 100644
index 0000000..13ee553
--- /dev/null
+++ b/src/com/android/customization/picker/quickaffordance/ui/binder/KeyguardQuickAffordancePickerPreviewBinder.kt
@@ -0,0 +1,78 @@
+/*
+ * 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.customization.picker.quickaffordance.ui.binder
+
+import android.view.View
+import android.widget.ImageView
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.lifecycleScope
+import androidx.lifecycle.repeatOnLifecycle
+import com.android.customization.picker.quickaffordance.ui.viewmodel.KeyguardQuickAffordancePickerViewModel
+import com.android.systemui.shared.keyguard.shared.model.KeyguardQuickAffordanceSlots
+import com.android.wallpaper.R
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.mapNotNull
+import kotlinx.coroutines.launch
+
+object KeyguardQuickAffordancePickerPreviewBinder {
+
+    /** Binds view with view-model for a lock screen quick affordance preview experience. */
+    @JvmStatic
+    fun bind(
+        view: View,
+        viewModel: KeyguardQuickAffordancePickerViewModel,
+        lifecycleOwner: LifecycleOwner,
+    ) {
+        val startView: ImageView = view.requireViewById(R.id.start_affordance)
+        val endView: ImageView = view.requireViewById(R.id.end_affordance)
+        lifecycleOwner.lifecycleScope.launch {
+            lifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
+                launch {
+                    updateView(
+                        view = startView,
+                        viewModel = viewModel,
+                        slotId = KeyguardQuickAffordanceSlots.SLOT_ID_BOTTOM_START,
+                    )
+                }
+
+                launch {
+                    updateView(
+                        view = endView,
+                        viewModel = viewModel,
+                        slotId = KeyguardQuickAffordanceSlots.SLOT_ID_BOTTOM_END,
+                    )
+                }
+            }
+        }
+    }
+
+    private suspend fun updateView(
+        view: ImageView,
+        viewModel: KeyguardQuickAffordancePickerViewModel,
+        slotId: String,
+    ) {
+        viewModel.slots
+            .mapNotNull { slotById -> slotById[slotId] }
+            .map { slot -> slot.selectedQuickAffordances.firstOrNull() }
+            .collect { affordance ->
+                view.setImageDrawable(affordance?.icon)
+                view.contentDescription = affordance?.contentDescription
+            }
+    }
+}
diff --git a/src/com/android/customization/picker/quickaffordance/ui/binder/KeyguardQuickAffordanceSectionViewBinder.kt b/src/com/android/customization/picker/quickaffordance/ui/binder/KeyguardQuickAffordanceSectionViewBinder.kt
new file mode 100644
index 0000000..c8880b9
--- /dev/null
+++ b/src/com/android/customization/picker/quickaffordance/ui/binder/KeyguardQuickAffordanceSectionViewBinder.kt
@@ -0,0 +1,61 @@
+/*
+ * 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.customization.picker.quickaffordance.ui.binder
+
+import android.view.View
+import android.widget.ImageView
+import android.widget.TextView
+import androidx.core.view.isVisible
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.flowWithLifecycle
+import androidx.lifecycle.lifecycleScope
+import com.android.customization.picker.quickaffordance.ui.viewmodel.KeyguardQuickAffordancePickerViewModel
+import com.android.wallpaper.R
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.launch
+
+object KeyguardQuickAffordanceSectionViewBinder {
+    fun bind(
+        view: View,
+        viewModel: KeyguardQuickAffordancePickerViewModel,
+        lifecycleOwner: LifecycleOwner,
+        onClicked: () -> Unit,
+    ) {
+        view.setOnClickListener { onClicked() }
+
+        val descriptionView: TextView =
+            view.requireViewById(R.id.keyguard_quick_affordance_description)
+        val icon1: ImageView = view.requireViewById(R.id.icon_1)
+        val icon2: ImageView = view.requireViewById(R.id.icon_2)
+
+        lifecycleOwner.lifecycleScope.launch {
+            viewModel.summary
+                .flowWithLifecycle(lifecycleOwner.lifecycle, Lifecycle.State.RESUMED)
+                .collectLatest { summary ->
+                    descriptionView.text = summary.description
+
+                    icon1.setImageDrawable(summary.icon1)
+                    icon1.isVisible = summary.icon1 != null
+
+                    icon2.setImageDrawable(summary.icon2)
+                    icon2.isVisible = summary.icon2 != null
+                }
+        }
+    }
+}
diff --git a/src/com/android/customization/picker/quickaffordance/ui/fragment/KeyguardQuickAffordancePickerFragment.kt b/src/com/android/customization/picker/quickaffordance/ui/fragment/KeyguardQuickAffordancePickerFragment.kt
new file mode 100644
index 0000000..c99c6e8
--- /dev/null
+++ b/src/com/android/customization/picker/quickaffordance/ui/fragment/KeyguardQuickAffordancePickerFragment.kt
@@ -0,0 +1,70 @@
+/*
+ * 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.customization.picker.quickaffordance.ui.fragment
+
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.lifecycle.ViewModelProvider
+import androidx.lifecycle.get
+import com.android.customization.module.ThemePickerInjector
+import com.android.customization.picker.quickaffordance.ui.binder.KeyguardQuickAffordancePickerBinder
+import com.android.wallpaper.R
+import com.android.wallpaper.module.InjectorProvider
+import com.android.wallpaper.picker.AppbarFragment
+
+class KeyguardQuickAffordancePickerFragment : AppbarFragment() {
+    companion object {
+        const val DESTINATION_ID = "quick_affordances"
+        @JvmStatic
+        fun newInstance(): KeyguardQuickAffordancePickerFragment {
+            return KeyguardQuickAffordancePickerFragment()
+        }
+    }
+
+    override fun onCreateView(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View {
+        val view =
+            inflater.inflate(
+                R.layout.fragment_lock_screen_quick_affordances,
+                container,
+                false,
+            )
+        setUpToolbar(view)
+        val injector = InjectorProvider.getInjector() as ThemePickerInjector
+        KeyguardQuickAffordancePickerBinder.bind(
+            view = view,
+            viewModel =
+                ViewModelProvider(
+                        requireActivity(),
+                        injector.getKeyguardQuickAffordancePickerViewModelFactory(requireContext()),
+                    )
+                    .get(),
+            lifecycleOwner = this,
+        )
+        return view
+    }
+
+    override fun getDefaultTitle(): CharSequence {
+        return requireContext().getString(R.string.keyguard_quick_affordance_title)
+    }
+}
diff --git a/src/com/android/customization/picker/quickaffordance/ui/section/KeyguardQuickAffordanceSectionController.kt b/src/com/android/customization/picker/quickaffordance/ui/section/KeyguardQuickAffordanceSectionController.kt
new file mode 100644
index 0000000..6b35d7c
--- /dev/null
+++ b/src/com/android/customization/picker/quickaffordance/ui/section/KeyguardQuickAffordanceSectionController.kt
@@ -0,0 +1,62 @@
+/*
+ * 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.customization.picker.quickaffordance.ui.section
+
+import android.content.Context
+import android.view.LayoutInflater
+import androidx.lifecycle.LifecycleOwner
+import com.android.customization.picker.quickaffordance.domain.interactor.KeyguardQuickAffordancePickerInteractor
+import com.android.customization.picker.quickaffordance.ui.binder.KeyguardQuickAffordanceSectionViewBinder
+import com.android.customization.picker.quickaffordance.ui.fragment.KeyguardQuickAffordancePickerFragment
+import com.android.customization.picker.quickaffordance.ui.view.KeyguardQuickAffordanceSectionView
+import com.android.customization.picker.quickaffordance.ui.viewmodel.KeyguardQuickAffordancePickerViewModel
+import com.android.wallpaper.R
+import com.android.wallpaper.model.CustomizationSectionController
+import com.android.wallpaper.model.CustomizationSectionController.CustomizationSectionNavigationController as NavigationController
+import kotlinx.coroutines.runBlocking
+
+class KeyguardQuickAffordanceSectionController(
+    private val navigationController: NavigationController,
+    private val interactor: KeyguardQuickAffordancePickerInteractor,
+    private val viewModel: KeyguardQuickAffordancePickerViewModel,
+    private val lifecycleOwner: LifecycleOwner,
+) : CustomizationSectionController<KeyguardQuickAffordanceSectionView> {
+
+    private val isFeatureEnabled: Boolean = runBlocking { interactor.isFeatureEnabled() }
+
+    override fun isAvailable(context: Context?): Boolean {
+        return isFeatureEnabled
+    }
+
+    override fun createView(context: Context?): KeyguardQuickAffordanceSectionView {
+        val view =
+            LayoutInflater.from(context)
+                .inflate(
+                    R.layout.keyguard_quick_affordance_section_view,
+                    null,
+                ) as KeyguardQuickAffordanceSectionView
+        KeyguardQuickAffordanceSectionViewBinder.bind(
+            view = view,
+            viewModel = viewModel,
+            lifecycleOwner = lifecycleOwner,
+        ) {
+            navigationController.navigateTo(KeyguardQuickAffordancePickerFragment.newInstance())
+        }
+        return view
+    }
+}
diff --git a/src/com/android/customization/picker/quickaffordance/ui/view/KeyguardQuickAffordanceSectionView.kt b/src/com/android/customization/picker/quickaffordance/ui/view/KeyguardQuickAffordanceSectionView.kt
new file mode 100644
index 0000000..daace7d
--- /dev/null
+++ b/src/com/android/customization/picker/quickaffordance/ui/view/KeyguardQuickAffordanceSectionView.kt
@@ -0,0 +1,31 @@
+/*
+ * 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.customization.picker.quickaffordance.ui.view
+
+import android.content.Context
+import android.util.AttributeSet
+import com.android.wallpaper.picker.SectionView
+
+class KeyguardQuickAffordanceSectionView(
+    context: Context?,
+    attrs: AttributeSet?,
+) :
+    SectionView(
+        context,
+        attrs,
+    )
diff --git a/src/com/android/customization/picker/quickaffordance/ui/viewmodel/KeyguardQuickAffordancePickerViewModel.kt b/src/com/android/customization/picker/quickaffordance/ui/viewmodel/KeyguardQuickAffordancePickerViewModel.kt
new file mode 100644
index 0000000..7ea776b
--- /dev/null
+++ b/src/com/android/customization/picker/quickaffordance/ui/viewmodel/KeyguardQuickAffordancePickerViewModel.kt
@@ -0,0 +1,330 @@
+/*
+ * 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.customization.picker.quickaffordance.ui.viewmodel
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.content.Intent
+import android.graphics.drawable.Drawable
+import androidx.annotation.DrawableRes
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.ViewModelProvider
+import androidx.lifecycle.viewModelScope
+import com.android.customization.picker.quickaffordance.domain.interactor.KeyguardQuickAffordancePickerInteractor
+import com.android.systemui.shared.keyguard.shared.model.KeyguardQuickAffordanceSlots
+import com.android.systemui.shared.quickaffordance.data.content.KeyguardQuickAffordanceProviderContract as Contract
+import com.android.wallpaper.R
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.launch
+
+/** Models UI state for a lock screen quick affordance picker experience. */
+@OptIn(ExperimentalCoroutinesApi::class)
+class KeyguardQuickAffordancePickerViewModel
+private constructor(
+    context: Context,
+    private val interactor: KeyguardQuickAffordancePickerInteractor,
+) : ViewModel() {
+
+    @SuppressLint("StaticFieldLeak") private val applicationContext = context.applicationContext
+
+    private val selectedSlotId = MutableStateFlow<String?>(null)
+
+    /** View-models for each slot, keyed by slot ID. */
+    val slots: Flow<Map<String, KeyguardQuickAffordanceSlotViewModel>> =
+        combine(
+            interactor.slots,
+            interactor.affordances,
+            interactor.selections,
+            selectedSlotId,
+        ) { slots, affordances, selections, selectedSlotIdOrNull ->
+            slots
+                .mapIndexed { index, slot ->
+                    val selectedAffordanceIds =
+                        selections
+                            .filter { selection -> selection.slotId == slot.id }
+                            .map { selection -> selection.affordanceId }
+                            .toSet()
+                    val selectedAffordances =
+                        affordances.filter { affordance ->
+                            selectedAffordanceIds.contains(affordance.id)
+                        }
+                    val isSelected =
+                        (selectedSlotIdOrNull == null && index == 0) ||
+                            selectedSlotIdOrNull == slot.id
+                    slot.id to
+                        KeyguardQuickAffordanceSlotViewModel(
+                            name = getSlotName(slot.id),
+                            isSelected = isSelected,
+                            selectedQuickAffordances =
+                                selectedAffordances.map { affordanceModel ->
+                                    KeyguardQuickAffordanceViewModel(
+                                        icon = getAffordanceIcon(affordanceModel.iconResourceId),
+                                        contentDescription = affordanceModel.name,
+                                        isSelected = true,
+                                        onClicked = null,
+                                        isEnabled = affordanceModel.isEnabled,
+                                    )
+                                },
+                            maxSelectedQuickAffordances = slot.maxSelectedQuickAffordances,
+                            onClicked =
+                                if (isSelected) {
+                                    null
+                                } else {
+                                    { this.selectedSlotId.value = slot.id }
+                                },
+                        )
+                }
+                .toMap()
+        }
+
+    /** The list of all available quick affordances for the selected slot. */
+    val quickAffordances: Flow<List<KeyguardQuickAffordanceViewModel>> =
+        combine(
+            interactor.slots,
+            interactor.affordances,
+            interactor.selections,
+            selectedSlotId,
+        ) { slots, affordances, selections, selectedSlotIdOrNull ->
+            val selectedSlot =
+                selectedSlotIdOrNull?.let { slots.find { slot -> slot.id == it } } ?: slots.first()
+            val selectedAffordanceIds =
+                selections
+                    .filter { selection -> selection.slotId == selectedSlot.id }
+                    .map { selection -> selection.affordanceId }
+                    .toSet()
+            listOf(
+                none(
+                    slotId = selectedSlot.id,
+                    isSelected = selectedAffordanceIds.isEmpty(),
+                )
+            ) +
+                affordances.map { affordance ->
+                    val isSelected = selectedAffordanceIds.contains(affordance.id)
+                    KeyguardQuickAffordanceViewModel(
+                        icon = getAffordanceIcon(affordance.iconResourceId),
+                        contentDescription = affordance.name,
+                        isSelected = isSelected,
+                        onClicked =
+                            if (affordance.isEnabled) {
+                                {
+                                    viewModelScope.launch {
+                                        if (isSelected) {
+                                            interactor.unselect(
+                                                slotId = selectedSlot.id,
+                                                affordanceId = affordance.id,
+                                            )
+                                        } else {
+                                            interactor.select(
+                                                slotId = selectedSlot.id,
+                                                affordanceId = affordance.id,
+                                            )
+                                        }
+                                    }
+                                }
+                            } else {
+                                {
+                                    showEnablementDialog(
+                                        instructionHeader =
+                                            affordance.enablementInstructions.first(),
+                                        instructions =
+                                            affordance.enablementInstructions.subList(
+                                                1,
+                                                affordance.enablementInstructions.size
+                                            ),
+                                        actionText = affordance.enablementActionText,
+                                        actionComponentName =
+                                            affordance.enablementActionComponentName,
+                                    )
+                                }
+                            },
+                        isEnabled = affordance.isEnabled,
+                    )
+                }
+        }
+
+    @SuppressLint("UseCompatLoadingForDrawables")
+    val summary: Flow<KeyguardQuickAffordanceSummaryViewModel> =
+        slots.map { slots ->
+            val icon2 =
+                slots[KeyguardQuickAffordanceSlots.SLOT_ID_BOTTOM_END]
+                    ?.selectedQuickAffordances
+                    ?.firstOrNull()
+                    ?.icon
+            val icon1 =
+                slots[KeyguardQuickAffordanceSlots.SLOT_ID_BOTTOM_START]
+                    ?.selectedQuickAffordances
+                    ?.firstOrNull()
+                    ?.icon
+
+            KeyguardQuickAffordanceSummaryViewModel(
+                description = toDescriptionText(context, slots),
+                icon1 = icon1
+                        ?: if (icon2 == null) {
+                            context.getDrawable(R.drawable.link_off)
+                        } else {
+                            null
+                        },
+                icon2 = icon2,
+            )
+        }
+
+    private val _dialog = MutableStateFlow<DialogViewModel?>(null)
+    /**
+     * The current dialog to show. If `null`, no dialog should be shown.
+     *
+     * When the dialog is dismissed, [onDialogDismissed] must be called.
+     */
+    val dialog: Flow<DialogViewModel?> = _dialog.asStateFlow()
+
+    /** Notifies that the dialog has been dismissed in the UI. */
+    fun onDialogDismissed() {
+        _dialog.value = null
+    }
+
+    private fun showEnablementDialog(
+        instructionHeader: String,
+        instructions: List<String>,
+        actionText: String?,
+        actionComponentName: String?,
+    ) {
+        _dialog.value =
+            DialogViewModel(
+                instructionHeader = instructionHeader,
+                instructions = instructions,
+                actionText = actionText
+                        ?: applicationContext.getString(
+                            R.string.keyguard_affordance_enablement_dialog_dismiss_button
+                        ),
+                intent = actionComponentName.toIntent(),
+            )
+    }
+
+    @SuppressLint("UseCompatLoadingForDrawables")
+    private fun none(
+        slotId: String,
+        isSelected: Boolean,
+    ): KeyguardQuickAffordanceViewModel {
+        return KeyguardQuickAffordanceViewModel.none(
+            context = applicationContext,
+            isSelected = isSelected,
+            onSelected = { viewModelScope.launch { interactor.unselectAll(slotId) } },
+        )
+    }
+
+    private fun getSlotName(slotId: String): String {
+        return applicationContext.getString(
+            when (slotId) {
+                KeyguardQuickAffordanceSlots.SLOT_ID_BOTTOM_START ->
+                    R.string.keyguard_slot_name_bottom_start
+                KeyguardQuickAffordanceSlots.SLOT_ID_BOTTOM_END ->
+                    R.string.keyguard_slot_name_bottom_end
+                else -> error("No name for slot with ID of \"$slotId\"!")
+            }
+        )
+    }
+
+    private suspend fun getAffordanceIcon(@DrawableRes iconResourceId: Int): Drawable {
+        return interactor.getAffordanceIcon(iconResourceId)
+    }
+
+    private fun String?.toIntent(): Intent? {
+        if (isNullOrEmpty()) {
+            return null
+        }
+
+        val splitUp = split(Contract.AffordanceTable.COMPONENT_NAME_SEPARATOR)
+        check(splitUp.size == 1 || splitUp.size == 2) {
+            "Illegal component name \"$this\". Must be either just an action or a package and an" +
+                " action separated by a" +
+                " \"${Contract.AffordanceTable.COMPONENT_NAME_SEPARATOR}\"!"
+        }
+
+        return Intent(splitUp.last()).apply {
+            if (splitUp.size > 1) {
+                setPackage(splitUp[0])
+            }
+        }
+    }
+
+    /** Encapsulates a request to show a dialog. */
+    data class DialogViewModel(
+        /** The header for the instructions section. */
+        val instructionHeader: String,
+
+        /** The set of instructions to show below the header. */
+        val instructions: List<String>,
+
+        /** Label for the dialog button. */
+        val actionText: String,
+
+        /**
+         * Optional [Intent] to use to start an activity when the dialog button is clicked. If
+         * `null`, the dialog should be dismissed.
+         */
+        val intent: Intent?,
+    )
+
+    private fun toDescriptionText(
+        context: Context,
+        slots: Map<String, KeyguardQuickAffordanceSlotViewModel>,
+    ): String {
+        val bottomStartAffordanceName =
+            slots[KeyguardQuickAffordanceSlots.SLOT_ID_BOTTOM_START]
+                ?.selectedQuickAffordances
+                ?.firstOrNull()
+                ?.contentDescription
+        val bottomEndAffordanceName =
+            slots[KeyguardQuickAffordanceSlots.SLOT_ID_BOTTOM_END]
+                ?.selectedQuickAffordances
+                ?.firstOrNull()
+                ?.contentDescription
+
+        return when {
+            !bottomStartAffordanceName.isNullOrEmpty() &&
+                !bottomEndAffordanceName.isNullOrEmpty() -> {
+                context.getString(
+                    R.string.keyguard_quick_affordance_two_selected_template,
+                    bottomStartAffordanceName,
+                    bottomEndAffordanceName,
+                )
+            }
+            !bottomStartAffordanceName.isNullOrEmpty() -> bottomStartAffordanceName
+            !bottomEndAffordanceName.isNullOrEmpty() -> bottomEndAffordanceName
+            else -> context.getString(R.string.keyguard_quick_affordance_none_selected)
+        }
+    }
+
+    class Factory(
+        private val context: Context,
+        private val interactor: KeyguardQuickAffordancePickerInteractor,
+    ) : ViewModelProvider.Factory {
+        override fun <T : ViewModel> create(modelClass: Class<T>): T {
+            @Suppress("UNCHECKED_CAST")
+            return KeyguardQuickAffordancePickerViewModel(
+                context = context,
+                interactor = interactor,
+            )
+                as T
+        }
+    }
+}
diff --git a/src/com/android/customization/picker/quickaffordance/ui/viewmodel/KeyguardQuickAffordanceSlotViewModel.kt b/src/com/android/customization/picker/quickaffordance/ui/viewmodel/KeyguardQuickAffordanceSlotViewModel.kt
new file mode 100644
index 0000000..bb9b29b
--- /dev/null
+++ b/src/com/android/customization/picker/quickaffordance/ui/viewmodel/KeyguardQuickAffordanceSlotViewModel.kt
@@ -0,0 +1,44 @@
+/*
+ * 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.customization.picker.quickaffordance.ui.viewmodel
+
+/** Models UI state for a single lock screen quick affordance slot in a picker experience. */
+data class KeyguardQuickAffordanceSlotViewModel(
+    /** User-visible name for the slot. */
+    val name: String,
+
+    /** Whether this is the currently-selected slot in the picker. */
+    val isSelected: Boolean,
+
+    /**
+     * The list of quick affordances selected for this slot.
+     *
+     * Useful for preview.
+     */
+    val selectedQuickAffordances: List<KeyguardQuickAffordanceViewModel>,
+
+    /**
+     * The maximum number of quick affordances that can be selected for this slot.
+     *
+     * Useful for picker and preview.
+     */
+    val maxSelectedQuickAffordances: Int,
+
+    /** Notifies that the slot has been clicked by the user. */
+    val onClicked: (() -> Unit)?,
+)
diff --git a/src/com/android/customization/picker/quickaffordance/ui/viewmodel/KeyguardQuickAffordanceSummaryViewModel.kt b/src/com/android/customization/picker/quickaffordance/ui/viewmodel/KeyguardQuickAffordanceSummaryViewModel.kt
new file mode 100644
index 0000000..d5fc79b
--- /dev/null
+++ b/src/com/android/customization/picker/quickaffordance/ui/viewmodel/KeyguardQuickAffordanceSummaryViewModel.kt
@@ -0,0 +1,26 @@
+/*
+ * 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.customization.picker.quickaffordance.ui.viewmodel
+
+import android.graphics.drawable.Drawable
+
+data class KeyguardQuickAffordanceSummaryViewModel(
+    val description: String,
+    val icon1: Drawable?,
+    val icon2: Drawable?,
+)
diff --git a/src/com/android/customization/picker/quickaffordance/ui/viewmodel/KeyguardQuickAffordanceViewModel.kt b/src/com/android/customization/picker/quickaffordance/ui/viewmodel/KeyguardQuickAffordanceViewModel.kt
new file mode 100644
index 0000000..d720b0c
--- /dev/null
+++ b/src/com/android/customization/picker/quickaffordance/ui/viewmodel/KeyguardQuickAffordanceViewModel.kt
@@ -0,0 +1,63 @@
+/*
+ * 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.customization.picker.quickaffordance.ui.viewmodel
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.graphics.drawable.Drawable
+import com.android.wallpaper.R
+
+/** Models UI state for a single lock screen quick affordance in a picker experience. */
+data class KeyguardQuickAffordanceViewModel(
+    /** An icon for the quick affordance. */
+    val icon: Drawable,
+
+    /** A content description for the icon. */
+    val contentDescription: String,
+
+    /** Whether this quick affordance is selected in its slot. */
+    val isSelected: Boolean,
+
+    /** Whether this quick affordance is enabled. */
+    val isEnabled: Boolean,
+
+    /** Notifies that the quick affordance has been clicked by the user. */
+    val onClicked: (() -> Unit)?,
+) {
+    companion object {
+        @SuppressLint("UseCompatLoadingForDrawables")
+        fun none(
+            context: Context,
+            isSelected: Boolean,
+            onSelected: () -> Unit,
+        ): KeyguardQuickAffordanceViewModel {
+            return KeyguardQuickAffordanceViewModel(
+                icon = checkNotNull(context.getDrawable(R.drawable.link_off)),
+                contentDescription = context.getString(R.string.keyguard_affordance_none),
+                isSelected = isSelected,
+                onClicked =
+                    if (isSelected) {
+                        null
+                    } else {
+                        onSelected
+                    },
+                isEnabled = true,
+            )
+        }
+    }
+}
diff --git a/src/com/android/customization/picker/theme/CustomThemeNameFragment.java b/src/com/android/customization/picker/theme/CustomThemeNameFragment.java
index 6f20a1a..ea9099f 100644
--- a/src/com/android/customization/picker/theme/CustomThemeNameFragment.java
+++ b/src/com/android/customization/picker/theme/CustomThemeNameFragment.java
@@ -69,7 +69,7 @@
         mTitle = view.findViewById(R.id.component_options_title);
         mTitle.setText(mTitleResId);
         CurrentWallpaperInfoFactory currentWallpaperFactory = InjectorProvider.getInjector()
-                .getCurrentWallpaperFactory(getActivity().getApplicationContext());
+                .getCurrentWallpaperInfoFactory(getActivity().getApplicationContext());
         CustomizationInjector injector = (CustomizationInjector) InjectorProvider.getInjector();
         mCustomizationPreferences = injector.getCustomizationPreferences(getContext());
 
diff --git a/src/com/android/customization/picker/theme/ThemeFragment.java b/src/com/android/customization/picker/theme/ThemeFragment.java
index f5d56ca..3a9a56f 100644
--- a/src/com/android/customization/picker/theme/ThemeFragment.java
+++ b/src/com/android/customization/picker/theme/ThemeFragment.java
@@ -115,7 +115,7 @@
         mLoading = view.findViewById(R.id.loading_indicator);
         mError = view.findViewById(R.id.error_section);
         mCurrentWallpaperFactory = InjectorProvider.getInjector()
-                .getCurrentWallpaperFactory(getActivity().getApplicationContext());
+                .getCurrentWallpaperInfoFactory(getActivity().getApplicationContext());
         mOptionsContainer = view.findViewById(R.id.options_container);
 
         mThemeOptionPreviewer = new ThemeOptionPreviewer(
diff --git a/src/com/android/customization/widget/OptionSelectorController.java b/src/com/android/customization/widget/OptionSelectorController.java
index ffd70e0..8805caf 100644
--- a/src/com/android/customization/widget/OptionSelectorController.java
+++ b/src/com/android/customization/widget/OptionSelectorController.java
@@ -44,8 +44,6 @@
 import com.android.customization.model.CustomizationManager;
 import com.android.customization.model.CustomizationOption;
 import com.android.wallpaper.R;
-import com.android.wallpaper.widget.GridPaddingDecoration;
-import com.android.wallpaper.widget.GridRowSpacerDecoration;
 
 import java.util.HashSet;
 import java.util.List;
@@ -285,16 +283,9 @@
 
         Resources res = mContainer.getContext().getResources();
         mContainer.setAdapter(mAdapter);
-        final int padding = res.getDimensionPixelSize(
-                R.dimen.option_tile_grid_padding_horizontal);
-        final int fixWidth = res.getDimensionPixelSize(R.dimen.options_container_width);
         final DisplayMetrics metrics = new DisplayMetrics();
         mContainer.getContext().getSystemService(WindowManager.class)
                 .getDefaultDisplay().getMetrics(metrics);
-        // This is based on the assumption that the parent view is the same width as the screen.
-        final int availableDynamicWidth = metrics.widthPixels - 2 * res.getDimensionPixelSize(
-                R.dimen.section_horizontal_padding);
-        final int availableWidth = (fixWidth != 0) ? fixWidth : availableDynamicWidth;
         final boolean hasDecoration = mContainer.getItemDecorationCount() != 0;
 
         if (mUseGrid) {
@@ -302,24 +293,15 @@
             GridLayoutManager gridLayoutManager = new GridLayoutManager(mContainer.getContext(),
                     numColumns);
             mContainer.setLayoutManager(gridLayoutManager);
-            if (!hasDecoration) {
-                mContainer.addItemDecoration(new GridPaddingDecoration(padding, 0));
-            }
-            // Measure RecyclerView to get to the total amount of space used by all options.
-            mContainer.measure(View.MeasureSpec.UNSPECIFIED, View.MeasureSpec.UNSPECIFIED);
-            while (mContainer.getMeasuredWidth() > availableWidth && numColumns > 1) {
-                numColumns -= 1;
-                gridLayoutManager.setSpanCount(numColumns);
-                mContainer.measure(View.MeasureSpec.UNSPECIFIED, View.MeasureSpec.UNSPECIFIED);
-            }
-            if (!hasDecoration && numColumns > 1) {
-                mContainer.addItemDecoration(new GridRowSpacerDecoration(2 * padding));
-            }
         } else {
+            final int padding = res.getDimensionPixelSize(
+                    R.dimen.option_tile_linear_padding_horizontal);
             final int widthPerItem = res.getDimensionPixelSize(R.dimen.option_tile_width) + (
                     hasDecoration ? 0 : 2 * padding);
             mContainer.setLayoutManager(new LinearLayoutManager(mContainer.getContext(),
                     LinearLayoutManager.HORIZONTAL, false));
+            mContainer.measure(View.MeasureSpec.UNSPECIFIED, View.MeasureSpec.UNSPECIFIED);
+            int availableWidth = metrics.widthPixels;
             int extraSpace = availableWidth - mContainer.getMeasuredWidth();
             if (extraSpace >= 0) {
                 mContainer.setOverScrollMode(View.OVER_SCROLL_NEVER);
@@ -331,10 +313,8 @@
                         - mContainer.getPaddingLeft();
                 int itemEndMargin =
                         spaceBetweenItems / (int) mLinearLayoutHorizontalDisplayOptionsMax;
-                if (itemEndMargin <= 0) {
-                    itemEndMargin = res.getDimensionPixelOffset(
-                            R.dimen.option_tile_margin_horizontal);
-                }
+                itemEndMargin = Math.max(itemEndMargin, res.getDimensionPixelOffset(
+                        R.dimen.option_tile_margin_horizontal));
                 mContainer.addItemDecoration(new ItemEndHorizontalSpaceItemDecoration(
                         mContainer.getContext(), itemEndMargin));
                 return;
diff --git a/src_override/com/android/wallpaper/config/Flags.java b/src_override/com/android/wallpaper/config/Flags.java
index 76549cb..42731de 100644
--- a/src_override/com/android/wallpaper/config/Flags.java
+++ b/src_override/com/android/wallpaper/config/Flags.java
@@ -16,5 +16,5 @@
 package com.android.wallpaper.config;
 
 public class Flags extends BaseFlags {
-    public static boolean enableClockCustomization = false;
+    public static boolean enableCustomClocks = false;
 }
diff --git a/src_override/com/android/wallpaper/module/WallpapersInjector.java b/src_override/com/android/wallpaper/module/WallpapersInjector.java
deleted file mode 100755
index 9f8fe9c..0000000
--- a/src_override/com/android/wallpaper/module/WallpapersInjector.java
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
- * Copyright (C) 2018 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.wallpaper.module;
-
-import android.content.Context;
-import android.content.Intent;
-import android.net.Uri;
-
-import androidx.fragment.app.Fragment;
-
-import com.android.wallpaper.model.CategoryProvider;
-import com.android.wallpaper.model.WallpaperInfo;
-import com.android.wallpaper.monitor.PerformanceMonitor;
-import com.android.wallpaper.picker.CustomizationPickerActivity;
-import com.android.wallpaper.picker.ImagePreviewFragment;
-
-/**
- * A concrete, real implementation of the dependency provider.
- */
-public class WallpapersInjector extends BaseWallpaperInjector {
-    private CategoryProvider mCategoryProvider;
-    private UserEventLogger mUserEventLogger;
-    private WallpaperRotationRefresher mWallpaperRotationRefresher;
-    private PerformanceMonitor mPerformanceMonitor;
-
-    @Override
-    public synchronized CategoryProvider getCategoryProvider(Context context) {
-        if (mCategoryProvider == null) {
-            mCategoryProvider = new DefaultCategoryProvider(context.getApplicationContext());
-        }
-        return mCategoryProvider;
-    }
-
-    @Override
-    public synchronized UserEventLogger getUserEventLogger(Context context) {
-        if (mUserEventLogger == null) {
-            mUserEventLogger = new NoOpUserEventLogger();
-        }
-        return mUserEventLogger;
-    }
-
-    @Override
-    public synchronized WallpaperRotationRefresher getWallpaperRotationRefresher() {
-        if (mWallpaperRotationRefresher == null) {
-            mWallpaperRotationRefresher = new WallpaperRotationRefresher() {
-                @Override
-                public void refreshWallpaper(Context context, Listener listener) {
-                    // Not implemented
-                    listener.onError();
-                }
-            };
-        }
-        return mWallpaperRotationRefresher;
-    }
-
-    @Override
-    public Fragment getPreviewFragment(
-            Context context,
-            WallpaperInfo wallpaperInfo,
-            int mode,
-            boolean viewAsHome,
-            boolean viewFullScreen,
-            boolean testingModeEnabled) {
-        return ImagePreviewFragment.newInstance(wallpaperInfo, mode, viewAsHome, viewFullScreen,
-                testingModeEnabled);
-    }
-
-    @Override
-    public Intent getDeepLinkRedirectIntent(Context context, Uri uri) {
-        Intent intent = new Intent();
-        intent.setClass(context, CustomizationPickerActivity.class);
-        intent.setData(uri);
-        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
-        return intent;
-    }
-
-    @Override
-    public synchronized PerformanceMonitor getPerformanceMonitor() {
-        if (mPerformanceMonitor == null) {
-            mPerformanceMonitor = new PerformanceMonitor() {
-                @Override
-                public void recordFullResPreviewLoadedMemorySnapshot() {
-                    // No Op
-                }
-            };
-        }
-        return mPerformanceMonitor;
-    }
-
-    @Override
-    public synchronized LoggingOptInStatusProvider getLoggingOptInStatusProvider(Context context) {
-        return null;
-    }
-
-    @Override
-    public String getDownloadableIntentAction() {
-        return null;
-    }
-}
diff --git a/tests/src/com/android/customization/model/picker/quickaffordance/data/repository/KeyguardQuickAffordancePickerRepositoryTest.kt b/tests/src/com/android/customization/model/picker/quickaffordance/data/repository/KeyguardQuickAffordancePickerRepositoryTest.kt
new file mode 100644
index 0000000..4a88f3b
--- /dev/null
+++ b/tests/src/com/android/customization/model/picker/quickaffordance/data/repository/KeyguardQuickAffordancePickerRepositoryTest.kt
@@ -0,0 +1,103 @@
+/*
+ * 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.customization.model.picker.quickaffordance.data.repository
+
+import androidx.test.filters.SmallTest
+import com.android.customization.picker.quickaffordance.data.repository.KeyguardQuickAffordancePickerRepository
+import com.android.systemui.shared.quickaffordance.data.content.FakeKeyguardQuickAffordanceProviderClient
+import com.google.common.truth.Truth.assertThat
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.toList
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.test.TestScope
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.test.setMain
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+
+@OptIn(ExperimentalCoroutinesApi::class)
+@SmallTest
+@RunWith(JUnit4::class)
+class KeyguardQuickAffordancePickerRepositoryTest {
+
+    private lateinit var underTest: KeyguardQuickAffordancePickerRepository
+
+    private lateinit var testScope: TestScope
+    private lateinit var client: FakeKeyguardQuickAffordanceProviderClient
+
+    @Before
+    fun setUp() {
+        client = FakeKeyguardQuickAffordanceProviderClient()
+        val coroutineDispatcher = UnconfinedTestDispatcher()
+        testScope = TestScope(coroutineDispatcher)
+        Dispatchers.setMain(coroutineDispatcher)
+
+        underTest =
+            KeyguardQuickAffordancePickerRepository(
+                client = client,
+                backgroundDispatcher = coroutineDispatcher,
+            )
+    }
+
+    @After
+    fun tearDown() {
+        Dispatchers.resetMain()
+    }
+
+    @Test
+    fun `isFeatureEnabled - enabled`() =
+        testScope.runTest {
+            client.setFlag(
+                com.android.systemui.shared.quickaffordance.data.content
+                    .KeyguardQuickAffordanceProviderContract
+                    .FlagsTable
+                    .FLAG_NAME_FEATURE_ENABLED,
+                true,
+            )
+            val values = mutableListOf<Boolean>()
+            val job = launch { underTest.isFeatureEnabled.toList(values) }
+
+            assertThat(values.last()).isTrue()
+
+            job.cancel()
+        }
+
+    @Test
+    fun `isFeatureEnabled - not enabled`() =
+        testScope.runTest {
+            client.setFlag(
+                com.android.systemui.shared.quickaffordance.data.content
+                    .KeyguardQuickAffordanceProviderContract
+                    .FlagsTable
+                    .FLAG_NAME_FEATURE_ENABLED,
+                false,
+            )
+            val values = mutableListOf<Boolean>()
+            val job = launch { underTest.isFeatureEnabled.toList(values) }
+
+            assertThat(values.last()).isFalse()
+
+            job.cancel()
+        }
+}
diff --git a/tests/src/com/android/customization/model/picker/quickaffordance/domain/interactor/KeyguardQuickAffordancePickerInteractorTest.kt b/tests/src/com/android/customization/model/picker/quickaffordance/domain/interactor/KeyguardQuickAffordancePickerInteractorTest.kt
new file mode 100644
index 0000000..d8a136d
--- /dev/null
+++ b/tests/src/com/android/customization/model/picker/quickaffordance/domain/interactor/KeyguardQuickAffordancePickerInteractorTest.kt
@@ -0,0 +1,158 @@
+/*
+ * 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.customization.model.picker.quickaffordance.domain.interactor
+
+import androidx.test.filters.SmallTest
+import com.android.customization.picker.quickaffordance.data.repository.KeyguardQuickAffordancePickerRepository
+import com.android.customization.picker.quickaffordance.domain.interactor.KeyguardQuickAffordancePickerInteractor
+import com.android.customization.picker.quickaffordance.shared.model.KeyguardQuickAffordancePickerSelectionModel
+import com.android.systemui.shared.keyguard.shared.model.KeyguardQuickAffordanceSlots
+import com.android.systemui.shared.quickaffordance.data.content.FakeKeyguardQuickAffordanceProviderClient
+import com.google.common.truth.Truth.assertThat
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.toList
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.test.TestScope
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.test.setMain
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+
+@OptIn(ExperimentalCoroutinesApi::class)
+@SmallTest
+@RunWith(JUnit4::class)
+class KeyguardQuickAffordancePickerInteractorTest {
+
+    private lateinit var underTest: KeyguardQuickAffordancePickerInteractor
+
+    private lateinit var testScope: TestScope
+    private lateinit var client: FakeKeyguardQuickAffordanceProviderClient
+
+    @Before
+    fun setUp() {
+        val coroutineDispatcher = UnconfinedTestDispatcher()
+        testScope = TestScope(coroutineDispatcher)
+        Dispatchers.setMain(coroutineDispatcher)
+        client = FakeKeyguardQuickAffordanceProviderClient()
+        underTest =
+            KeyguardQuickAffordancePickerInteractor(
+                repository =
+                    KeyguardQuickAffordancePickerRepository(
+                        client = client,
+                        backgroundDispatcher = coroutineDispatcher,
+                    ),
+                client = client,
+            )
+    }
+
+    @After
+    fun tearDown() {
+        Dispatchers.resetMain()
+    }
+
+    @Test
+    fun select() =
+        testScope.runTest {
+            val selections = mutableListOf<List<KeyguardQuickAffordancePickerSelectionModel>>()
+            val job = launch { underTest.selections.toList(selections) }
+
+            underTest.select(
+                slotId = KeyguardQuickAffordanceSlots.SLOT_ID_BOTTOM_START,
+                affordanceId = FakeKeyguardQuickAffordanceProviderClient.AFFORDANCE_1,
+            )
+            assertThat(selections.last())
+                .isEqualTo(
+                    listOf(
+                        KeyguardQuickAffordancePickerSelectionModel(
+                            slotId = KeyguardQuickAffordanceSlots.SLOT_ID_BOTTOM_START,
+                            affordanceId = FakeKeyguardQuickAffordanceProviderClient.AFFORDANCE_1,
+                        ),
+                    )
+                )
+
+            underTest.select(
+                slotId = KeyguardQuickAffordanceSlots.SLOT_ID_BOTTOM_START,
+                affordanceId = FakeKeyguardQuickAffordanceProviderClient.AFFORDANCE_2,
+            )
+            assertThat(selections.last())
+                .isEqualTo(
+                    listOf(
+                        KeyguardQuickAffordancePickerSelectionModel(
+                            slotId = KeyguardQuickAffordanceSlots.SLOT_ID_BOTTOM_START,
+                            affordanceId = FakeKeyguardQuickAffordanceProviderClient.AFFORDANCE_2,
+                        ),
+                    )
+                )
+
+            job.cancel()
+        }
+
+    @Test
+    fun unselect() =
+        testScope.runTest {
+            val selections = mutableListOf<List<KeyguardQuickAffordancePickerSelectionModel>>()
+            val job = launch { underTest.selections.toList(selections) }
+            underTest.select(
+                slotId = KeyguardQuickAffordanceSlots.SLOT_ID_BOTTOM_START,
+                affordanceId = FakeKeyguardQuickAffordanceProviderClient.AFFORDANCE_1,
+            )
+
+            underTest.unselect(
+                slotId = KeyguardQuickAffordanceSlots.SLOT_ID_BOTTOM_START,
+                affordanceId = FakeKeyguardQuickAffordanceProviderClient.AFFORDANCE_1,
+            )
+
+            assertThat(selections.last()).isEmpty()
+
+            job.cancel()
+        }
+
+    @Test
+    fun unselectAll() =
+        testScope.runTest {
+            client.setSlotCapacity(KeyguardQuickAffordanceSlots.SLOT_ID_BOTTOM_END, 3)
+            val selections = mutableListOf<List<KeyguardQuickAffordancePickerSelectionModel>>()
+            val job = launch { underTest.selections.toList(selections) }
+            underTest.select(
+                slotId = KeyguardQuickAffordanceSlots.SLOT_ID_BOTTOM_END,
+                affordanceId = FakeKeyguardQuickAffordanceProviderClient.AFFORDANCE_1,
+            )
+            underTest.select(
+                slotId = KeyguardQuickAffordanceSlots.SLOT_ID_BOTTOM_END,
+                affordanceId = FakeKeyguardQuickAffordanceProviderClient.AFFORDANCE_2,
+            )
+            underTest.select(
+                slotId = KeyguardQuickAffordanceSlots.SLOT_ID_BOTTOM_END,
+                affordanceId = FakeKeyguardQuickAffordanceProviderClient.AFFORDANCE_3,
+            )
+
+            underTest.unselectAll(
+                slotId = KeyguardQuickAffordanceSlots.SLOT_ID_BOTTOM_END,
+            )
+
+            assertThat(selections.last()).isEmpty()
+
+            job.cancel()
+        }
+}
diff --git a/tests/src/com/android/customization/model/picker/quickaffordance/ui/viewmodel/KeyguardQuickAffordancePickerViewModelTest.kt b/tests/src/com/android/customization/model/picker/quickaffordance/ui/viewmodel/KeyguardQuickAffordancePickerViewModelTest.kt
new file mode 100644
index 0000000..d446e1b
--- /dev/null
+++ b/tests/src/com/android/customization/model/picker/quickaffordance/ui/viewmodel/KeyguardQuickAffordancePickerViewModelTest.kt
@@ -0,0 +1,457 @@
+/*
+ * 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.customization.model.picker.quickaffordance.ui.viewmodel
+
+import android.content.Context
+import androidx.test.filters.SmallTest
+import androidx.test.platform.app.InstrumentationRegistry
+import com.android.customization.picker.quickaffordance.data.repository.KeyguardQuickAffordancePickerRepository
+import com.android.customization.picker.quickaffordance.domain.interactor.KeyguardQuickAffordancePickerInteractor
+import com.android.customization.picker.quickaffordance.ui.viewmodel.KeyguardQuickAffordancePickerViewModel
+import com.android.customization.picker.quickaffordance.ui.viewmodel.KeyguardQuickAffordanceSlotViewModel
+import com.android.customization.picker.quickaffordance.ui.viewmodel.KeyguardQuickAffordanceSummaryViewModel
+import com.android.customization.picker.quickaffordance.ui.viewmodel.KeyguardQuickAffordanceViewModel
+import com.android.systemui.shared.keyguard.shared.model.KeyguardQuickAffordanceSlots
+import com.android.systemui.shared.quickaffordance.data.content.FakeKeyguardQuickAffordanceProviderClient
+import com.android.systemui.shared.quickaffordance.data.content.KeyguardQuickAffordanceProviderClient
+import com.google.common.truth.Truth.assertThat
+import com.google.common.truth.Truth.assertWithMessage
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.toList
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.test.TestScope
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.test.setMain
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+
+@OptIn(ExperimentalCoroutinesApi::class)
+@SmallTest
+@RunWith(JUnit4::class)
+class KeyguardQuickAffordancePickerViewModelTest {
+
+    private lateinit var underTest: KeyguardQuickAffordancePickerViewModel
+
+    private lateinit var context: Context
+    private lateinit var testScope: TestScope
+    private lateinit var client: FakeKeyguardQuickAffordanceProviderClient
+
+    @Before
+    fun setUp() {
+        context = InstrumentationRegistry.getInstrumentation().targetContext
+        val coroutineDispatcher = UnconfinedTestDispatcher()
+        testScope = TestScope(coroutineDispatcher)
+        Dispatchers.setMain(coroutineDispatcher)
+        client = FakeKeyguardQuickAffordanceProviderClient()
+
+        underTest =
+            KeyguardQuickAffordancePickerViewModel.Factory(
+                    context = context,
+                    interactor =
+                        KeyguardQuickAffordancePickerInteractor(
+                            repository =
+                                KeyguardQuickAffordancePickerRepository(
+                                    client = client,
+                                    backgroundDispatcher = coroutineDispatcher,
+                                ),
+                            client = client,
+                        ),
+                )
+                .create(KeyguardQuickAffordancePickerViewModel::class.java)
+    }
+
+    @After
+    fun tearDown() {
+        Dispatchers.resetMain()
+    }
+
+    @Test
+    fun `Select an affordance for each side`() =
+        testScope.runTest {
+            val slots = mutableListOf<Map<String, KeyguardQuickAffordanceSlotViewModel>>()
+            val quickAffordances = mutableListOf<List<KeyguardQuickAffordanceViewModel>>()
+
+            val jobs = buildList {
+                add(launch { underTest.slots.toList(slots) })
+                add(launch { underTest.quickAffordances.toList(quickAffordances) })
+            }
+
+            // Initially, the first slot is selected with the "none" affordance selected.
+            assertPickerUiState(
+                slots = slots.last(),
+                affordances = quickAffordances.last(),
+                selectedSlotText = "Left button",
+                selectedAffordanceText = "None",
+            )
+            assertPreviewUiState(
+                slots = slots.last(),
+                expectedAffordanceNameBySlotId =
+                    mapOf(
+                        KeyguardQuickAffordanceSlots.SLOT_ID_BOTTOM_START to null,
+                        KeyguardQuickAffordanceSlots.SLOT_ID_BOTTOM_END to null,
+                    ),
+            )
+
+            // Select "affordance 1" for the first slot.
+            quickAffordances.last()[1].onClicked?.invoke()
+            assertPickerUiState(
+                slots = slots.last(),
+                affordances = quickAffordances.last(),
+                selectedSlotText = "Left button",
+                selectedAffordanceText = FakeKeyguardQuickAffordanceProviderClient.AFFORDANCE_1,
+            )
+            assertPreviewUiState(
+                slots = slots.last(),
+                expectedAffordanceNameBySlotId =
+                    mapOf(
+                        KeyguardQuickAffordanceSlots.SLOT_ID_BOTTOM_START to
+                            FakeKeyguardQuickAffordanceProviderClient.AFFORDANCE_1,
+                        KeyguardQuickAffordanceSlots.SLOT_ID_BOTTOM_END to null,
+                    ),
+            )
+
+            // Select an affordance for the second slot.
+            // First, switch to the second slot:
+            slots.last()[KeyguardQuickAffordanceSlots.SLOT_ID_BOTTOM_END]?.onClicked?.invoke()
+            // Second, select the "affordance 3" affordance:
+            quickAffordances.last()[3].onClicked?.invoke()
+            assertPickerUiState(
+                slots = slots.last(),
+                affordances = quickAffordances.last(),
+                selectedSlotText = "Right button",
+                selectedAffordanceText = FakeKeyguardQuickAffordanceProviderClient.AFFORDANCE_3,
+            )
+            assertPreviewUiState(
+                slots = slots.last(),
+                expectedAffordanceNameBySlotId =
+                    mapOf(
+                        KeyguardQuickAffordanceSlots.SLOT_ID_BOTTOM_START to
+                            FakeKeyguardQuickAffordanceProviderClient.AFFORDANCE_1,
+                        KeyguardQuickAffordanceSlots.SLOT_ID_BOTTOM_END to
+                            FakeKeyguardQuickAffordanceProviderClient.AFFORDANCE_3,
+                    ),
+            )
+
+            // Select a different affordance for the second slot.
+            quickAffordances.last()[2].onClicked?.invoke()
+            assertPickerUiState(
+                slots = slots.last(),
+                affordances = quickAffordances.last(),
+                selectedSlotText = "Right button",
+                selectedAffordanceText = FakeKeyguardQuickAffordanceProviderClient.AFFORDANCE_2,
+            )
+            assertPreviewUiState(
+                slots = slots.last(),
+                expectedAffordanceNameBySlotId =
+                    mapOf(
+                        KeyguardQuickAffordanceSlots.SLOT_ID_BOTTOM_START to
+                            FakeKeyguardQuickAffordanceProviderClient.AFFORDANCE_1,
+                        KeyguardQuickAffordanceSlots.SLOT_ID_BOTTOM_END to
+                            FakeKeyguardQuickAffordanceProviderClient.AFFORDANCE_2,
+                    ),
+            )
+
+            jobs.forEach { it.cancel() }
+        }
+
+    @Test
+    fun `Unselect - AKA selecting the none affordance - on one side`() =
+        testScope.runTest {
+            val slots = mutableListOf<Map<String, KeyguardQuickAffordanceSlotViewModel>>()
+            val quickAffordances = mutableListOf<List<KeyguardQuickAffordanceViewModel>>()
+
+            val jobs = buildList {
+                add(launch { underTest.slots.toList(slots) })
+                add(launch { underTest.quickAffordances.toList(quickAffordances) })
+            }
+
+            // Select "affordance 1" for the first slot.
+            quickAffordances.last()[1].onClicked?.invoke()
+            // Select an affordance for the second slot.
+            // First, switch to the second slot:
+            slots.last()[KeyguardQuickAffordanceSlots.SLOT_ID_BOTTOM_END]?.onClicked?.invoke()
+            // Second, select the "affordance 3" affordance:
+            quickAffordances.last()[3].onClicked?.invoke()
+
+            // Switch back to the first slot:
+            slots.last()[KeyguardQuickAffordanceSlots.SLOT_ID_BOTTOM_START]?.onClicked?.invoke()
+            // Select the "none" affordance, which is always in position 0:
+            quickAffordances.last()[0].onClicked?.invoke()
+
+            assertPickerUiState(
+                slots = slots.last(),
+                affordances = quickAffordances.last(),
+                selectedSlotText = "Left button",
+                selectedAffordanceText = "None",
+            )
+            assertPreviewUiState(
+                slots = slots.last(),
+                expectedAffordanceNameBySlotId =
+                    mapOf(
+                        KeyguardQuickAffordanceSlots.SLOT_ID_BOTTOM_START to null,
+                        KeyguardQuickAffordanceSlots.SLOT_ID_BOTTOM_END to
+                            FakeKeyguardQuickAffordanceProviderClient.AFFORDANCE_3,
+                    ),
+            )
+
+            jobs.forEach { it.cancel() }
+        }
+
+    @Test
+    fun `Show enablement dialog when selecting a disabled affordance`() =
+        testScope.runTest {
+            val slots = mutableListOf<Map<String, KeyguardQuickAffordanceSlotViewModel>>()
+            val quickAffordances = mutableListOf<List<KeyguardQuickAffordanceViewModel>>()
+            val dialog = mutableListOf<KeyguardQuickAffordancePickerViewModel.DialogViewModel?>()
+
+            val jobs = buildList {
+                add(launch { underTest.slots.toList(slots) })
+                add(launch { underTest.quickAffordances.toList(quickAffordances) })
+                add(launch { underTest.dialog.toList(dialog) })
+            }
+            val enablementInstructions = listOf("header", "enablementInstructions")
+            val enablementActionText = "enablementActionText"
+            val packageName = "packageName"
+            val action = "action"
+            val enablementActionComponentName = "$packageName/$action"
+            // Lets add a disabled affordance to the picker:
+            val affordanceIndex =
+                client.addAffordance(
+                    KeyguardQuickAffordanceProviderClient.Affordance(
+                        id = "disabled",
+                        name = "disabled",
+                        iconResourceId = 0,
+                        isEnabled = false,
+                        enablementInstructions = enablementInstructions,
+                        enablementActionText = enablementActionText,
+                        enablementActionComponentName = enablementActionComponentName,
+                    )
+                )
+
+            // Lets try to select that disabled affordance:
+            quickAffordances.last()[affordanceIndex + 1].onClicked?.invoke()
+
+            // We expect there to be a dialog that should be shown:
+            assertThat(dialog.last()?.instructionHeader).isEqualTo(enablementInstructions[0])
+            assertThat(dialog.last()?.instructions)
+                .isEqualTo(enablementInstructions.subList(1, enablementInstructions.size))
+            assertThat(dialog.last()?.actionText).isEqualTo(enablementActionText)
+            assertThat(dialog.last()?.intent?.`package`).isEqualTo(packageName)
+            assertThat(dialog.last()?.intent?.action).isEqualTo(action)
+
+            // Once we report that the dialog has been dismissed by the user, we expect there to be
+            // no
+            // dialog to be shown:
+            underTest.onDialogDismissed()
+            assertThat(dialog.last()).isNull()
+
+            jobs.forEach { it.cancel() }
+        }
+
+    @Test
+    fun `summary - affordance selected in both bottom-start and bottom-end`() =
+        testScope.runTest {
+            val slots = mutableListOf<Map<String, KeyguardQuickAffordanceSlotViewModel>>()
+            val quickAffordances = mutableListOf<List<KeyguardQuickAffordanceViewModel>>()
+            val summary = mutableListOf<KeyguardQuickAffordanceSummaryViewModel>()
+            val jobs = buildList {
+                add(launch { underTest.slots.toList(slots) })
+                add(launch { underTest.quickAffordances.toList(quickAffordances) })
+                add(launch { underTest.summary.toList(summary) })
+            }
+
+            // Select "affordance 1" for the first slot.
+            quickAffordances.last()[1].onClicked?.invoke()
+            // Select an affordance for the second slot.
+            // First, switch to the second slot:
+            slots.last()[KeyguardQuickAffordanceSlots.SLOT_ID_BOTTOM_END]?.onClicked?.invoke()
+            // Second, select the "affordance 3" affordance:
+            quickAffordances.last()[3].onClicked?.invoke()
+
+            assertThat(summary.last())
+                .isEqualTo(
+                    KeyguardQuickAffordanceSummaryViewModel(
+                        description =
+                            "${FakeKeyguardQuickAffordanceProviderClient.AFFORDANCE_1}," +
+                                " ${FakeKeyguardQuickAffordanceProviderClient.AFFORDANCE_3}",
+                        icon1 = FakeKeyguardQuickAffordanceProviderClient.ICON_1,
+                        icon2 = FakeKeyguardQuickAffordanceProviderClient.ICON_3,
+                    )
+                )
+            jobs.forEach { it.cancel() }
+        }
+
+    @Test
+    fun `summary - affordance selected only on bottom-start`() =
+        testScope.runTest {
+            val slots = mutableListOf<Map<String, KeyguardQuickAffordanceSlotViewModel>>()
+            val quickAffordances = mutableListOf<List<KeyguardQuickAffordanceViewModel>>()
+            val summary = mutableListOf<KeyguardQuickAffordanceSummaryViewModel>()
+            val jobs = buildList {
+                add(launch { underTest.slots.toList(slots) })
+                add(launch { underTest.quickAffordances.toList(quickAffordances) })
+                add(launch { underTest.summary.toList(summary) })
+            }
+
+            // Select "affordance 1" for the first slot.
+            quickAffordances.last()[1].onClicked?.invoke()
+
+            assertThat(summary.last())
+                .isEqualTo(
+                    KeyguardQuickAffordanceSummaryViewModel(
+                        description = FakeKeyguardQuickAffordanceProviderClient.AFFORDANCE_1,
+                        icon1 = FakeKeyguardQuickAffordanceProviderClient.ICON_1,
+                        icon2 = null,
+                    )
+                )
+            jobs.forEach { it.cancel() }
+        }
+
+    @Test
+    fun `summary - affordance selected only on bottom-end`() =
+        testScope.runTest {
+            val slots = mutableListOf<Map<String, KeyguardQuickAffordanceSlotViewModel>>()
+            val quickAffordances = mutableListOf<List<KeyguardQuickAffordanceViewModel>>()
+            val summary = mutableListOf<KeyguardQuickAffordanceSummaryViewModel>()
+            val jobs = buildList {
+                add(launch { underTest.slots.toList(slots) })
+                add(launch { underTest.quickAffordances.toList(quickAffordances) })
+                add(launch { underTest.summary.toList(summary) })
+            }
+
+            // Select an affordance for the second slot.
+            // First, switch to the second slot:
+            slots.last()[KeyguardQuickAffordanceSlots.SLOT_ID_BOTTOM_END]?.onClicked?.invoke()
+            // Second, select the "affordance 3" affordance:
+            quickAffordances.last()[3].onClicked?.invoke()
+
+            assertThat(summary.last())
+                .isEqualTo(
+                    KeyguardQuickAffordanceSummaryViewModel(
+                        description = FakeKeyguardQuickAffordanceProviderClient.AFFORDANCE_3,
+                        icon1 = null,
+                        icon2 = FakeKeyguardQuickAffordanceProviderClient.ICON_3,
+                    )
+                )
+            jobs.forEach { it.cancel() }
+        }
+
+    @Test
+    fun `summary - no affordances selected`() =
+        testScope.runTest {
+            val slots = mutableListOf<Map<String, KeyguardQuickAffordanceSlotViewModel>>()
+            val quickAffordances = mutableListOf<List<KeyguardQuickAffordanceViewModel>>()
+            val summary = mutableListOf<KeyguardQuickAffordanceSummaryViewModel>()
+            val jobs = buildList {
+                add(launch { underTest.slots.toList(slots) })
+                add(launch { underTest.quickAffordances.toList(quickAffordances) })
+                add(launch { underTest.summary.toList(summary) })
+            }
+
+            assertThat(summary.last().description).isEqualTo("None")
+            assertThat(summary.last().icon1).isNotNull()
+            assertThat(summary.last().icon2).isNull()
+            jobs.forEach { it.cancel() }
+        }
+
+    /**
+     * Asserts the entire picker UI state is what is expected. This includes the slot tabs and the
+     * affordance list.
+     *
+     * @param slots The observed slot view-models, keyed by slot ID
+     * @param affordances The observed affordances
+     * @param selectedSlotText The text of the slot that's expected to be selected
+     * @param selectedAffordanceText The text of the affordance that's expected to be selected
+     */
+    private fun assertPickerUiState(
+        slots: Map<String, KeyguardQuickAffordanceSlotViewModel>,
+        affordances: List<KeyguardQuickAffordanceViewModel>,
+        selectedSlotText: String,
+        selectedAffordanceText: String,
+    ) {
+        assertSlotTabUiState(
+            slots = slots,
+            slotId = KeyguardQuickAffordanceSlots.SLOT_ID_BOTTOM_START,
+            isSelected = "Left button" == selectedSlotText,
+        )
+        assertSlotTabUiState(
+            slots = slots,
+            slotId = KeyguardQuickAffordanceSlots.SLOT_ID_BOTTOM_END,
+            isSelected = "Right button" == selectedSlotText,
+        )
+
+        var foundSelectedAffordance = false
+        affordances.forEach { affordance ->
+            val nameMatchesSelectedName = affordance.contentDescription == selectedAffordanceText
+            assertWithMessage(
+                    "Expected affordance with name \"${affordance.contentDescription}\" to have" +
+                        " isSelected=$nameMatchesSelectedName but it was ${affordance.isSelected}"
+                )
+                .that(affordance.isSelected)
+                .isEqualTo(nameMatchesSelectedName)
+            foundSelectedAffordance = foundSelectedAffordance || nameMatchesSelectedName
+        }
+        assertWithMessage("No affordance is selected!").that(foundSelectedAffordance).isTrue()
+    }
+
+    /**
+     * Asserts that a slot tab has the correct UI state.
+     *
+     * @param slots The observed slot view-models, keyed by slot ID
+     * @param slotId the ID of the slot to assert
+     * @param isSelected Whether that slot should be selected
+     */
+    private fun assertSlotTabUiState(
+        slots: Map<String, KeyguardQuickAffordanceSlotViewModel>,
+        slotId: String,
+        isSelected: Boolean,
+    ) {
+        val viewModel = slots[slotId] ?: error("No slot with ID \"$slotId\"!")
+        assertThat(viewModel.isSelected).isEqualTo(isSelected)
+    }
+
+    /**
+     * Asserts the UI state of the preview.
+     *
+     * @param slots The observed slot view-models, keyed by slot ID
+     * @param expectedAffordanceNameBySlotId The expected name of the selected affordance for each
+     * slot ID or `null` if it's expected for there to be no affordance for that slot in the preview
+     */
+    private fun assertPreviewUiState(
+        slots: Map<String, KeyguardQuickAffordanceSlotViewModel>,
+        expectedAffordanceNameBySlotId: Map<String, String?>,
+    ) {
+        slots.forEach { (slotId, slotViewModel) ->
+            val expectedAffordanceName = expectedAffordanceNameBySlotId[slotId]
+            val actualAffordanceName =
+                slotViewModel.selectedQuickAffordances.firstOrNull()?.contentDescription
+            assertWithMessage(
+                    "At slotId=\"$slotId\", expected affordance=\"$expectedAffordanceName\" but" +
+                        " was \"$actualAffordanceName\"!"
+                )
+                .that(actualAffordanceName)
+                .isEqualTo(expectedAffordanceName)
+        }
+    }
+}
diff --git a/tests/src/com/android/customization/testing/TestCustomizationInjector.java b/tests/src/com/android/customization/testing/TestCustomizationInjector.java
index dbbdb74..15898c1 100644
--- a/tests/src/com/android/customization/testing/TestCustomizationInjector.java
+++ b/tests/src/com/android/customization/testing/TestCustomizationInjector.java
@@ -10,11 +10,18 @@
 import com.android.customization.module.CustomizationInjector;
 import com.android.customization.module.CustomizationPreferences;
 import com.android.customization.module.ThemesUserEventLogger;
+import com.android.customization.picker.quickaffordance.data.repository.KeyguardQuickAffordancePickerRepository;
+import com.android.customization.picker.quickaffordance.domain.interactor.KeyguardQuickAffordancePickerInteractor;
+import com.android.customization.picker.quickaffordance.ui.viewmodel.KeyguardQuickAffordancePickerViewModel;
+import com.android.systemui.shared.quickaffordance.data.content.KeyguardQuickAffordanceProviderClient;
+import com.android.systemui.shared.quickaffordance.data.content.KeyguardQuickAffordanceProviderClientImpl;
 import com.android.wallpaper.module.DrawableLayerResolver;
 import com.android.wallpaper.module.PackageStatusNotifier;
 import com.android.wallpaper.module.UserEventLogger;
 import com.android.wallpaper.testing.TestInjector;
 
+import kotlinx.coroutines.Dispatchers;
+
 /**
  * Test implementation of the dependency injector.
  */
@@ -24,6 +31,9 @@
     private PackageStatusNotifier mPackageStatusNotifier;
     private DrawableLayerResolver mDrawableLayerResolver;
     private UserEventLogger mUserEventLogger;
+    private KeyguardQuickAffordancePickerInteractor mKeyguardQuickAffordancePickerInteractor;
+    private KeyguardQuickAffordancePickerViewModel.Factory
+            mKeyguardQuickAffordancePickerViewModelFactory;
 
     @Override
     public CustomizationPreferences getCustomizationPreferences(Context context) {
@@ -68,4 +78,17 @@
         }
         return mUserEventLogger;
     }
+
+    @Override
+    public KeyguardQuickAffordancePickerInteractor getKeyguardQuickAffordancePickerInteractor(
+            Context context) {
+        if (mKeyguardQuickAffordancePickerInteractor == null) {
+            final KeyguardQuickAffordanceProviderClient client =
+                    new KeyguardQuickAffordanceProviderClientImpl(context, Dispatchers.getIO());
+            mKeyguardQuickAffordancePickerInteractor = new KeyguardQuickAffordancePickerInteractor(
+                    new KeyguardQuickAffordancePickerRepository(client, Dispatchers.getIO()),
+                    client);
+        }
+        return mKeyguardQuickAffordancePickerInteractor;
+    }
 }
diff --git a/themes/res/values-af/strings.xml b/themes/res/values-af/strings.xml
deleted file mode 100644
index 59e659c..0000000
--- a/themes/res/values-af/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Rooi"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Oranje"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Geel"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Groen"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Blou"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Pers"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Magenta"</string>
-</resources>
diff --git a/themes/res/values-am/strings.xml b/themes/res/values-am/strings.xml
deleted file mode 100644
index 7b22f4c..0000000
--- a/themes/res/values-am/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"ቀይ"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"ብርቱካናማ"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"ቢጫ"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"አረንጓዴ"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"ሰማያዊ"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"ሐምራዊ"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"ማጀንታ"</string>
-</resources>
diff --git a/themes/res/values-ar/strings.xml b/themes/res/values-ar/strings.xml
deleted file mode 100644
index e1fb282..0000000
--- a/themes/res/values-ar/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"أحمر"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"برتقالي"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"أصفر"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"أخضر"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"أزرق"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"بنفسجي"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"أرجواني"</string>
-</resources>
diff --git a/themes/res/values-as/strings.xml b/themes/res/values-as/strings.xml
deleted file mode 100644
index 38642d5..0000000
--- a/themes/res/values-as/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"ৰঙা"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"কমলা"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"হালধীয়া"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"সেউজীয়া"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"নীলা"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"বেঙুনীয়া"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"মেজেণ্টা"</string>
-</resources>
diff --git a/themes/res/values-az/strings.xml b/themes/res/values-az/strings.xml
deleted file mode 100644
index ed3a3dc..0000000
--- a/themes/res/values-az/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Qırmızı"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Narıncı"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Sarı"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Yaşıl"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Göy"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Mor"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Çəhrayı qırmızı"</string>
-</resources>
diff --git a/themes/res/values-b+sr+Latn/strings.xml b/themes/res/values-b+sr+Latn/strings.xml
deleted file mode 100644
index 4227e14..0000000
--- a/themes/res/values-b+sr+Latn/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Crvena"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Narandžasta"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Žuta"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Zelena"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Plava"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Ljubičasta"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Magenta"</string>
-</resources>
diff --git a/themes/res/values-be/strings.xml b/themes/res/values-be/strings.xml
deleted file mode 100644
index 7e0130d..0000000
--- a/themes/res/values-be/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Чырвоны"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Аранжавы"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Жоўты"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Зялёны"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Сіні"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Фіялетавы"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Пурпурны"</string>
-</resources>
diff --git a/themes/res/values-bg/strings.xml b/themes/res/values-bg/strings.xml
deleted file mode 100644
index 1aa2b0a..0000000
--- a/themes/res/values-bg/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Червено"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Оранжево"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Жълто"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Зелено"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Синьо"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Лилаво"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Пурпурно"</string>
-</resources>
diff --git a/themes/res/values-bn/strings.xml b/themes/res/values-bn/strings.xml
deleted file mode 100644
index 942eea1..0000000
--- a/themes/res/values-bn/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"লাল"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"কমলা"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"হলুদ"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"সবুজ"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"নীল"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"বেগুনি"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"ম্যাজেন্টা"</string>
-</resources>
diff --git a/themes/res/values-bs/strings.xml b/themes/res/values-bs/strings.xml
deleted file mode 100644
index 4227e14..0000000
--- a/themes/res/values-bs/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Crvena"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Narandžasta"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Žuta"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Zelena"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Plava"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Ljubičasta"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Magenta"</string>
-</resources>
diff --git a/themes/res/values-ca/strings.xml b/themes/res/values-ca/strings.xml
deleted file mode 100644
index 6ccf839..0000000
--- a/themes/res/values-ca/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Vermell"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Taronja"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Groc"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Verd"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Blau"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Lila"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Magenta"</string>
-</resources>
diff --git a/themes/res/values-cs/strings.xml b/themes/res/values-cs/strings.xml
deleted file mode 100644
index 6be2bc6..0000000
--- a/themes/res/values-cs/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Červená"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Oranžová"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Žlutá"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Zelená"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Modrá"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Nachová"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Purpurová"</string>
-</resources>
diff --git a/themes/res/values-da/strings.xml b/themes/res/values-da/strings.xml
deleted file mode 100644
index ef759c2..0000000
--- a/themes/res/values-da/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Rød"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Orange"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Gul"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Grøn"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Blå"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Lilla"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Magenta"</string>
-</resources>
diff --git a/themes/res/values-de/strings.xml b/themes/res/values-de/strings.xml
deleted file mode 100644
index ba95a0b..0000000
--- a/themes/res/values-de/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Rot"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Orange"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Gelb"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Grün"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Blau"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Lila"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Magenta"</string>
-</resources>
diff --git a/themes/res/values-el/strings.xml b/themes/res/values-el/strings.xml
deleted file mode 100644
index 5e47c23..0000000
--- a/themes/res/values-el/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Κόκκινο"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Πορτοκαλί"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Κίτρινο"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Πράσινο"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Μπλε"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Μοβ"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Ματζέντα"</string>
-</resources>
diff --git a/themes/res/values-en-rAU/strings.xml b/themes/res/values-en-rAU/strings.xml
deleted file mode 100644
index f10dfca..0000000
--- a/themes/res/values-en-rAU/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Red"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Orange"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Yellow"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Green"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Blue"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Purple"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Magenta"</string>
-</resources>
diff --git a/themes/res/values-en-rCA/strings.xml b/themes/res/values-en-rCA/strings.xml
deleted file mode 100644
index f10dfca..0000000
--- a/themes/res/values-en-rCA/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Red"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Orange"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Yellow"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Green"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Blue"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Purple"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Magenta"</string>
-</resources>
diff --git a/themes/res/values-en-rGB/strings.xml b/themes/res/values-en-rGB/strings.xml
deleted file mode 100644
index f10dfca..0000000
--- a/themes/res/values-en-rGB/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Red"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Orange"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Yellow"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Green"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Blue"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Purple"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Magenta"</string>
-</resources>
diff --git a/themes/res/values-en-rIN/strings.xml b/themes/res/values-en-rIN/strings.xml
deleted file mode 100644
index f10dfca..0000000
--- a/themes/res/values-en-rIN/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Red"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Orange"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Yellow"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Green"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Blue"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Purple"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Magenta"</string>
-</resources>
diff --git a/themes/res/values-en-rXC/strings.xml b/themes/res/values-en-rXC/strings.xml
deleted file mode 100644
index c6114a4..0000000
--- a/themes/res/values-en-rXC/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‏‎‎‎‎‎‎‎‏‏‏‏‏‏‏‏‏‏‏‏‎‎‏‏‏‎‏‏‎‏‏‎‎‏‎‎‏‏‏‏‎‏‎‏‏‏‎‏‎‏‎‏‏‎‎‎‎‏‏‎‎‏‎‏‏‏‎‎‎‎‎‎‏‏‏‏‎‏‏‏‎‎Red‎‏‎‎‏‎"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‏‎‎‎‎‎‎‎‏‏‏‏‏‏‏‏‏‎‏‎‏‎‎‎‏‎‎‎‏‎‏‎‏‎‎‎‏‎‎‏‏‎‎‎‎‏‎‎‎‏‏‏‎‎‏‏‎‎‎‏‎‏‎‎‏‎‏‎‎‏‏‎‏‎‎‎‎‏‏‏‎Orange‎‏‎‎‏‎"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‏‎‎‎‎‎‎‎‏‏‏‏‏‏‏‏‏‏‏‏‏‏‎‎‎‎‏‏‎‎‏‎‏‏‏‎‏‎‏‎‏‎‎‏‎‏‏‏‎‎‏‏‏‏‎‎‎‎‎‎‎‎‏‎‏‏‏‎‏‎‏‏‏‎‏‎‏‎‎‎‏‎Yellow‎‏‎‎‏‎"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‏‎‎‎‎‎‎‎‏‏‏‏‏‏‏‏‎‏‏‏‎‏‎‏‏‎‏‎‎‏‏‎‎‎‎‎‏‏‎‎‎‎‏‏‏‎‏‏‎‏‏‎‎‏‏‏‎‏‎‏‎‏‎‎‏‏‎‏‏‏‎‏‎‏‏‎‎‎‎‎Green‎‏‎‎‏‎"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‏‎‎‎‎‎‎‎‏‏‏‏‏‏‏‏‏‎‏‏‎‎‎‎‎‎‏‏‎‎‏‏‎‎‏‏‎‎‏‏‏‏‎‎‎‏‏‎‎‏‎‎‏‏‏‏‎‎‏‏‏‏‏‏‎‎‎‎‏‎‎‏‏‎‏‏‏‏‎‎‎Blue‎‏‎‎‏‎"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‏‎‎‎‎‎‎‎‏‏‏‏‏‏‏‏‏‎‏‎‎‏‎‏‏‎‎‎‏‎‎‏‎‎‎‏‏‎‏‎‏‏‎‎‏‏‏‎‎‏‎‎‏‏‏‎‎‎‎‏‎‎‏‎‎‎‎‎‏‏‏‎‏‎‎‎‎‏‎‎‎Purple‎‏‎‎‏‎"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‏‎‎‎‎‎‎‎‏‏‏‏‏‏‏‏‏‏‏‏‎‎‏‎‎‏‎‎‏‏‎‎‎‏‎‎‏‎‎‎‏‏‎‎‎‏‎‏‎‏‏‏‎‏‎‏‎‎‏‏‏‎‎‏‏‏‏‎‎‏‏‎‏‏‏‏‎‎‎‎‏‎Magenta‎‏‎‎‏‎"</string>
-</resources>
diff --git a/themes/res/values-es-rUS/strings.xml b/themes/res/values-es-rUS/strings.xml
deleted file mode 100644
index a5f43a3..0000000
--- a/themes/res/values-es-rUS/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Rojo"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Naranja"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Amarillo"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Verde"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Azul"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Púrpura"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Magenta"</string>
-</resources>
diff --git a/themes/res/values-es/strings.xml b/themes/res/values-es/strings.xml
deleted file mode 100644
index f32bbcc..0000000
--- a/themes/res/values-es/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Rojo"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Naranja"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Amarillo"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Verde"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Azul"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Morado"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Magenta"</string>
-</resources>
diff --git a/themes/res/values-et/strings.xml b/themes/res/values-et/strings.xml
deleted file mode 100644
index c80e028..0000000
--- a/themes/res/values-et/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Punane"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Oranž"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Kollane"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Roheline"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Sinine"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Lilla"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Magenta"</string>
-</resources>
diff --git a/themes/res/values-eu/strings.xml b/themes/res/values-eu/strings.xml
deleted file mode 100644
index def8ca4..0000000
--- a/themes/res/values-eu/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Gorria"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Laranja"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Horia"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Berdea"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Urdina"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Morea"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Magenta"</string>
-</resources>
diff --git a/themes/res/values-fa/strings.xml b/themes/res/values-fa/strings.xml
deleted file mode 100644
index e6628d4..0000000
--- a/themes/res/values-fa/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"قرمز"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"نارنجی"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"زرد"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"سبز"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"آبی"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"بنفش"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"سرخابی"</string>
-</resources>
diff --git a/themes/res/values-fi/strings.xml b/themes/res/values-fi/strings.xml
deleted file mode 100644
index 385c7c8..0000000
--- a/themes/res/values-fi/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Punainen"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Oranssi"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Keltainen"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Vihreä"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Sininen"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Violetti"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Magenta"</string>
-</resources>
diff --git a/themes/res/values-fr-rCA/strings.xml b/themes/res/values-fr-rCA/strings.xml
deleted file mode 100644
index 38a69e4..0000000
--- a/themes/res/values-fr-rCA/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Rouge"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Orange"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Jaune"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Vert"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Bleu"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Mauve"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Magenta"</string>
-</resources>
diff --git a/themes/res/values-fr/strings.xml b/themes/res/values-fr/strings.xml
deleted file mode 100644
index 1141778..0000000
--- a/themes/res/values-fr/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Rouge"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Orange"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Jaune"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Vert"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Bleu"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Violet"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Magenta"</string>
-</resources>
diff --git a/themes/res/values-gl/strings.xml b/themes/res/values-gl/strings.xml
deleted file mode 100644
index 874f304..0000000
--- a/themes/res/values-gl/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Vermello"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Laranxa"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Amarelo"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Verde"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Azul"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Violeta"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Maxenta"</string>
-</resources>
diff --git a/themes/res/values-gu/strings.xml b/themes/res/values-gu/strings.xml
deleted file mode 100644
index b9f0ca4..0000000
--- a/themes/res/values-gu/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"લાલ"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"નારંગી"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"પીળો"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"લીલો"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"વાદળી"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"જાંબલી"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"મજેન્ટા"</string>
-</resources>
diff --git a/themes/res/values-hi/strings.xml b/themes/res/values-hi/strings.xml
deleted file mode 100644
index eb63fb5..0000000
--- a/themes/res/values-hi/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"लाल"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"नारंगी"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"पीला"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"हरा"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"नीला"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"बैंगनी"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"मजेंटा"</string>
-</resources>
diff --git a/themes/res/values-hr/strings.xml b/themes/res/values-hr/strings.xml
deleted file mode 100644
index acfe739..0000000
--- a/themes/res/values-hr/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Crvena"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Narančasta"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Žuta"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Zelena"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Plava"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Ljubičasta"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Grimizna"</string>
-</resources>
diff --git a/themes/res/values-hu/strings.xml b/themes/res/values-hu/strings.xml
deleted file mode 100644
index 1daa4ec..0000000
--- a/themes/res/values-hu/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Piros"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Narancssárga"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Sárga"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Zöld"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Kék"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Lila"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Magenta"</string>
-</resources>
diff --git a/themes/res/values-hy/strings.xml b/themes/res/values-hy/strings.xml
deleted file mode 100644
index 433aa7d..0000000
--- a/themes/res/values-hy/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Կարմիր"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Նարնջագույն"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Դեղին"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Կանաչ"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Կապույտ"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Մանուշակագույն"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Մորեգույն"</string>
-</resources>
diff --git a/themes/res/values-in/strings.xml b/themes/res/values-in/strings.xml
deleted file mode 100644
index fd1ad80..0000000
--- a/themes/res/values-in/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Merah"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Oranye"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Kuning"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Hijau"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Biru"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Ungu"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Magenta"</string>
-</resources>
diff --git a/themes/res/values-is/strings.xml b/themes/res/values-is/strings.xml
deleted file mode 100644
index dd333db..0000000
--- a/themes/res/values-is/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Rauður"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Appelsínugulur"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Gulur"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Grænn"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Blár"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Fjólublár"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Blárauður"</string>
-</resources>
diff --git a/themes/res/values-it/strings.xml b/themes/res/values-it/strings.xml
deleted file mode 100644
index b57ac74..0000000
--- a/themes/res/values-it/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Rosso"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Arancione"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Giallo"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Verde"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Blu"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Viola"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Magenta"</string>
-</resources>
diff --git a/themes/res/values-iw/strings.xml b/themes/res/values-iw/strings.xml
deleted file mode 100644
index 50a7541..0000000
--- a/themes/res/values-iw/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"אדום"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"כתום"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"צהוב"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"ירוק"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"כחול"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"סגול"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"מג\'נטה"</string>
-</resources>
diff --git a/themes/res/values-ja/strings.xml b/themes/res/values-ja/strings.xml
deleted file mode 100644
index 24e552d..0000000
--- a/themes/res/values-ja/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"赤"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"オレンジ"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"黄"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"緑"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"青"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"紫"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"マゼンタ"</string>
-</resources>
diff --git a/themes/res/values-ka/strings.xml b/themes/res/values-ka/strings.xml
deleted file mode 100644
index ea2d235..0000000
--- a/themes/res/values-ka/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"წითელი"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"ფორთოხლისფერი"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"ყვითელი"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"მწვანე"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"ლურჯი"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"იისფერი"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"მეწამული"</string>
-</resources>
diff --git a/themes/res/values-kk/strings.xml b/themes/res/values-kk/strings.xml
deleted file mode 100644
index bc6aa76..0000000
--- a/themes/res/values-kk/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Қызыл"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Қызғылт сары"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Сары"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Жасыл"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Көк"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Күлгін"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Қызғылт күлгін"</string>
-</resources>
diff --git a/themes/res/values-km/strings.xml b/themes/res/values-km/strings.xml
deleted file mode 100644
index b3ace48..0000000
--- a/themes/res/values-km/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"ក្រហម"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"ទឹកក្រូច"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"លឿង"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"បៃតង"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"ខៀវ"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"ស្វាយ"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"ក្រហមស្វាយ"</string>
-</resources>
diff --git a/themes/res/values-kn/strings.xml b/themes/res/values-kn/strings.xml
deleted file mode 100644
index abd1b72..0000000
--- a/themes/res/values-kn/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"ಕೆಂಪು"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"ಕಿತ್ತಳೆ"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"ಹಳದಿ"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"ಹಸಿರು"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"ನೀಲಿ"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"ನೇರಳೆ"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"ಮೆಜೆಂತಾ"</string>
-</resources>
diff --git a/themes/res/values-ko/strings.xml b/themes/res/values-ko/strings.xml
deleted file mode 100644
index 3c5710e..0000000
--- a/themes/res/values-ko/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"빨간색"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"주황색"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"노란색"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"녹색"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"파란색"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"보라색"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"자홍색"</string>
-</resources>
diff --git a/themes/res/values-ky/strings.xml b/themes/res/values-ky/strings.xml
deleted file mode 100644
index abcc95e..0000000
--- a/themes/res/values-ky/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Кызыл"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Кызгылт сары"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Сары"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Жашыл"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Көк"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Кызгылт"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Маджента"</string>
-</resources>
diff --git a/themes/res/values-lo/strings.xml b/themes/res/values-lo/strings.xml
deleted file mode 100644
index e4d1ebf..0000000
--- a/themes/res/values-lo/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"ສີແດງ"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"ສີສົ້ມ"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"ສີເຫຼືອງ"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"ສີຂຽວ"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"ສີຟ້າ"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"ສີມ່ວງ"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"ສີແດງມ່ວງ"</string>
-</resources>
diff --git a/themes/res/values-lt/strings.xml b/themes/res/values-lt/strings.xml
deleted file mode 100644
index 0a6396e..0000000
--- a/themes/res/values-lt/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Raudona"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Oranžinė"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Geltona"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Žalia"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Mėlyna"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Violetinė"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Purpurinė"</string>
-</resources>
diff --git a/themes/res/values-lv/strings.xml b/themes/res/values-lv/strings.xml
deleted file mode 100644
index 9b4038e..0000000
--- a/themes/res/values-lv/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Sarkana"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Oranža"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Dzeltena"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Zaļa"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Zila"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Violeta"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Fuksīna"</string>
-</resources>
diff --git a/themes/res/values-mk/strings.xml b/themes/res/values-mk/strings.xml
deleted file mode 100644
index 82a9b2c..0000000
--- a/themes/res/values-mk/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Црвена"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Портокалова"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Жолта"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Зелена"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Сина"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Виолетова"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Магента"</string>
-</resources>
diff --git a/themes/res/values-ml/strings.xml b/themes/res/values-ml/strings.xml
deleted file mode 100644
index fac9906..0000000
--- a/themes/res/values-ml/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"ചുവപ്പ്"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"ഓറഞ്ച്"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"മഞ്ഞ"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"പച്ച"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"നീല"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"പർപ്പിൾ"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"മജന്ത"</string>
-</resources>
diff --git a/themes/res/values-mn/strings.xml b/themes/res/values-mn/strings.xml
deleted file mode 100644
index ac9d8ba..0000000
--- a/themes/res/values-mn/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Улаан"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Улбар шар"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Шар"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Ногоон"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Цэнхэр"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Нил ягаан"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Гүн нил ягаан"</string>
-</resources>
diff --git a/themes/res/values-mr/strings.xml b/themes/res/values-mr/strings.xml
deleted file mode 100644
index 742cb47..0000000
--- a/themes/res/values-mr/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"लाल"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"नारिंगी"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"पिवळा"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"हिरवा"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"निळा"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"जांभळा"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"मजेंटा"</string>
-</resources>
diff --git a/themes/res/values-ms/strings.xml b/themes/res/values-ms/strings.xml
deleted file mode 100644
index eda40ca..0000000
--- a/themes/res/values-ms/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Merah"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Jingga"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Kuning"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Hijau"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Biru"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Ungu"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Magenta"</string>
-</resources>
diff --git a/themes/res/values-my/strings.xml b/themes/res/values-my/strings.xml
deleted file mode 100644
index 58d3f31..0000000
--- a/themes/res/values-my/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"အနီရောင်"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"လိမ္မော်ရောင်"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"အဝါရောင်"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"အစိမ်းရောင်"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"အပြာရောင်"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"ခရမ်းရောင်"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"ပန်းခရမ်း"</string>
-</resources>
diff --git a/themes/res/values-nb/strings.xml b/themes/res/values-nb/strings.xml
deleted file mode 100644
index cc42d6c..0000000
--- a/themes/res/values-nb/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Rød"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Oransje"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Gul"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Grønn"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Blå"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Lilla"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Magenta"</string>
-</resources>
diff --git a/themes/res/values-ne/strings.xml b/themes/res/values-ne/strings.xml
deleted file mode 100644
index a5c223e..0000000
--- a/themes/res/values-ne/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"रातो"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"सुन्तले रङ"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"पहेँलो"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"हरियो"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"निलो"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"बैजनी"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"मजेन्टा"</string>
-</resources>
diff --git a/themes/res/values-nl/strings.xml b/themes/res/values-nl/strings.xml
deleted file mode 100644
index 1a10728..0000000
--- a/themes/res/values-nl/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Rood"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Oranje"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Geel"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Groen"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Blauw"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Paars"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Magenta"</string>
-</resources>
diff --git a/themes/res/values-or/strings.xml b/themes/res/values-or/strings.xml
deleted file mode 100644
index be0b57d..0000000
--- a/themes/res/values-or/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"ଲାଲ୍"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"କମଳା"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"ହଳଦିଆ"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"ସବୁଜ"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"ନୀଳ"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"ବାଇଗଣୀ"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"ମାଜେଣ୍ଟା"</string>
-</resources>
diff --git a/themes/res/values-pa/strings.xml b/themes/res/values-pa/strings.xml
deleted file mode 100644
index dae483e..0000000
--- a/themes/res/values-pa/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"ਲਾਲ"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"ਸੰਤਰੀ"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"ਪੀਲਾ"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"ਹਰਾ"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"ਨੀਲਾ"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"ਜਾਮਨੀ"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"ਮੈਜੰਟਾ"</string>
-</resources>
diff --git a/themes/res/values-pl/strings.xml b/themes/res/values-pl/strings.xml
deleted file mode 100644
index c34d133..0000000
--- a/themes/res/values-pl/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Czerwony"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Pomarańczowy"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Żółty"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Zielony"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Niebieski"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Fioletowy"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Amarantowy"</string>
-</resources>
diff --git a/themes/res/values-pt-rPT/strings.xml b/themes/res/values-pt-rPT/strings.xml
deleted file mode 100644
index 0558b58..0000000
--- a/themes/res/values-pt-rPT/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Vermelho"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Laranja"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Amarelo"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Verde"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Azul"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Roxo"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Magenta"</string>
-</resources>
diff --git a/themes/res/values-pt/strings.xml b/themes/res/values-pt/strings.xml
deleted file mode 100644
index 0558b58..0000000
--- a/themes/res/values-pt/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Vermelho"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Laranja"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Amarelo"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Verde"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Azul"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Roxo"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Magenta"</string>
-</resources>
diff --git a/themes/res/values-ro/strings.xml b/themes/res/values-ro/strings.xml
deleted file mode 100644
index 35c2abe..0000000
--- a/themes/res/values-ro/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Roșu"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Portocaliu"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Galben"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Verde"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Albastru"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Violet"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Magenta"</string>
-</resources>
diff --git a/themes/res/values-ru/strings.xml b/themes/res/values-ru/strings.xml
deleted file mode 100644
index 77e82f8..0000000
--- a/themes/res/values-ru/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Красный"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Оранжевый"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Желтый"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Зеленый"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Синий"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Фиолетовый"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Пурпурный"</string>
-</resources>
diff --git a/themes/res/values-si/strings.xml b/themes/res/values-si/strings.xml
deleted file mode 100644
index 1da790a..0000000
--- a/themes/res/values-si/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"රතු"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"තැඹිලි"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"කහ"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"කොළ"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"නිල්"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"දම්"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"මැජෙන්ටා"</string>
-</resources>
diff --git a/themes/res/values-sk/strings.xml b/themes/res/values-sk/strings.xml
deleted file mode 100644
index e08467f..0000000
--- a/themes/res/values-sk/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Červená"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Oranžová"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Žltá"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Zelená"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Modrá"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Fialová"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Ružovofialová"</string>
-</resources>
diff --git a/themes/res/values-sl/strings.xml b/themes/res/values-sl/strings.xml
deleted file mode 100644
index 6c808c3..0000000
--- a/themes/res/values-sl/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Rdeča"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Oranžna"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Rumena"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Zelena"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Modra"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Vijolična"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Magenta"</string>
-</resources>
diff --git a/themes/res/values-sq/strings.xml b/themes/res/values-sq/strings.xml
deleted file mode 100644
index 7c4f53c..0000000
--- a/themes/res/values-sq/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"E kuqe"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Portokalli"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"E verdhë"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"E gjelbër"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Blu"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Vjollcë"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"E purpurt"</string>
-</resources>
diff --git a/themes/res/values-sr/strings.xml b/themes/res/values-sr/strings.xml
deleted file mode 100644
index 68155e0..0000000
--- a/themes/res/values-sr/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Црвена"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Наранџаста"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Жута"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Зелена"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Плава"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Љубичаста"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Магента"</string>
-</resources>
diff --git a/themes/res/values-sv/strings.xml b/themes/res/values-sv/strings.xml
deleted file mode 100644
index c6f7f20..0000000
--- a/themes/res/values-sv/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Röd"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Orange"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Gul"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Grön"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Blå"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Lila"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Magenta"</string>
-</resources>
diff --git a/themes/res/values-sw/strings.xml b/themes/res/values-sw/strings.xml
deleted file mode 100644
index 0b1b90a..0000000
--- a/themes/res/values-sw/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Nyekundu"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Rangi ya machungwa"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Njano"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Kijani"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Bluu"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Zambarau"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Majenta"</string>
-</resources>
diff --git a/themes/res/values-ta/strings.xml b/themes/res/values-ta/strings.xml
deleted file mode 100644
index 4b76331..0000000
--- a/themes/res/values-ta/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"சிவப்பு"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"ஆரஞ்சு"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"மஞ்சள்"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"பச்சை"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"நீலம்"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"ஊதா"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"மெஜந்தா"</string>
-</resources>
diff --git a/themes/res/values-te/strings.xml b/themes/res/values-te/strings.xml
deleted file mode 100644
index e6b0246..0000000
--- a/themes/res/values-te/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"ఎరుపు రంగు"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"నారింజ రంగు"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"పసుపు రంగు"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"ఆకుపచ్చ రంగు"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"నీలం"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"ఊదా రంగు"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"మెజెంటా రంగు"</string>
-</resources>
diff --git a/themes/res/values-th/strings.xml b/themes/res/values-th/strings.xml
deleted file mode 100644
index e597d2b..0000000
--- a/themes/res/values-th/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"แดง"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"ส้ม"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"เหลือง"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"เขียว"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"น้ำเงิน"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"ม่วง"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"ม่วงแดง"</string>
-</resources>
diff --git a/themes/res/values-tl/strings.xml b/themes/res/values-tl/strings.xml
deleted file mode 100644
index c57e5be..0000000
--- a/themes/res/values-tl/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Pula"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Orange"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Dilaw"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Berde"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Asul"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Purple"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Magenta"</string>
-</resources>
diff --git a/themes/res/values-tr/strings.xml b/themes/res/values-tr/strings.xml
deleted file mode 100644
index e825d77..0000000
--- a/themes/res/values-tr/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Kırmızı"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Turuncu"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Sarı"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Yeşil"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Mavi"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Mor"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Macenta"</string>
-</resources>
diff --git a/themes/res/values-uk/strings.xml b/themes/res/values-uk/strings.xml
deleted file mode 100644
index a839046..0000000
--- a/themes/res/values-uk/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Червоний"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Оранжевий"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Жовтий"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Зелений"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Синій"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Фіолетовий"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Пурпуровий"</string>
-</resources>
diff --git a/themes/res/values-ur/strings.xml b/themes/res/values-ur/strings.xml
deleted file mode 100644
index de5bd32..0000000
--- a/themes/res/values-ur/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"سرخ"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"نارنجی"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"پیلا"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"سبز"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"نیلا"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"جامنی"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"میجنٹا"</string>
-</resources>
diff --git a/themes/res/values-uz/strings.xml b/themes/res/values-uz/strings.xml
deleted file mode 100644
index f077f56..0000000
--- a/themes/res/values-uz/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Qizil"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Toʻq sariq"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Sariq"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Yashil"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Koʻk"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Siyohrang"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Qirmizi"</string>
-</resources>
diff --git a/themes/res/values-vi/strings.xml b/themes/res/values-vi/strings.xml
deleted file mode 100644
index 4eaf609..0000000
--- a/themes/res/values-vi/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Đỏ"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Cam"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Vàng"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Xanh lục"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Xanh lam"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Tím"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Đỏ tía"</string>
-</resources>
diff --git a/themes/res/values-zh-rCN/strings.xml b/themes/res/values-zh-rCN/strings.xml
deleted file mode 100644
index e49ed58..0000000
--- a/themes/res/values-zh-rCN/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"红色"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"橙色"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"黄色"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"绿色"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"蓝色"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"紫色"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"品红色"</string>
-</resources>
diff --git a/themes/res/values-zh-rHK/strings.xml b/themes/res/values-zh-rHK/strings.xml
deleted file mode 100644
index 007c561..0000000
--- a/themes/res/values-zh-rHK/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"紅色"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"橙色"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"黃色"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"綠色"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"藍色"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"紫色"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"紫紅色"</string>
-</resources>
diff --git a/themes/res/values-zh-rTW/strings.xml b/themes/res/values-zh-rTW/strings.xml
deleted file mode 100644
index 79c9ba6..0000000
--- a/themes/res/values-zh-rTW/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"紅色"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"橘色"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"黃色"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"綠色"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"藍色"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"紫色"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"洋紅色"</string>
-</resources>
diff --git a/themes/res/values-zu/strings.xml b/themes/res/values-zu/strings.xml
deleted file mode 100644
index 290c1e9..0000000
--- a/themes/res/values-zu/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-  ~ 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.
-   -->
-
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="rainbow_color_name_red" msgid="7452506008058561006">"Okubomvu"</string>
-    <string name="rainbow_color_name_orange" msgid="2921298510262609543">"Okuwolintshi"</string>
-    <string name="rainbow_color_name_yellow" msgid="8675574652757989201">"Okuphuzi"</string>
-    <string name="rainbow_color_name_green" msgid="1932895389710184112">"Okuluhlaza okotshani"</string>
-    <string name="rainbow_color_name_blue" msgid="3473176664458856892">"Okuluhlaza okwesibhakabhaka"</string>
-    <string name="rainbow_color_name_purple" msgid="2704722524588084868">"Okuphephuli"</string>
-    <string name="rainbow_color_name_magenta" msgid="7248703626077785569">"Oku-magenta"</string>
-</resources>
diff --git a/themes/res/values/color-bundles.xml b/themes/res/values/color-bundles.xml
index 4d7cc63..ced594e 100644
--- a/themes/res/values/color-bundles.xml
+++ b/themes/res/values/color-bundles.xml
@@ -16,6 +16,7 @@
   -->
 <resources>
     <array name="color_bundles">
+        <item>monochromatic</item>
         <item>rainbow1</item>
         <item>rainbow2</item>
         <item>rainbow3</item>
diff --git a/themes/res/values/colors.xml b/themes/res/values/colors.xml
index 3ffb9fc..53a4966 100644
--- a/themes/res/values/colors.xml
+++ b/themes/res/values/colors.xml
@@ -15,6 +15,8 @@
   ~ limitations under the License.
   -->
 <resources>
+<!--TODO(b/257218629)-->
+    <color name="color_secondary_monochromatic">#FFFF00</color>
     <color name="color_secondary_rainbow1">#FFB2B5</color>
     <color name="color_secondary_rainbow2">#FFB868</color>
     <color name="color_secondary_rainbow3">#E9C44A</color>
diff --git a/themes/res/values/strings.xml b/themes/res/values/strings.xml
index 8bc04bd..31363f7 100644
--- a/themes/res/values/strings.xml
+++ b/themes/res/values/strings.xml
@@ -23,6 +23,7 @@
     <string name="rainbow_color_name_blue">Blue</string>
     <string name="rainbow_color_name_purple">Purple</string>
     <string name="rainbow_color_name_magenta">Magenta</string>
+    <string name="monochromatic_name">Monochromatic</string>
 
     <string name="bundle_name_rainbow1" translatable="false">@string/rainbow_color_name_red</string>
     <string name="bundle_name_rainbow2" translatable="false">@string/rainbow_color_name_orange</string>
@@ -31,6 +32,7 @@
     <string name="bundle_name_rainbow5" translatable="false">@string/rainbow_color_name_blue</string>
     <string name="bundle_name_rainbow6" translatable="false">@string/rainbow_color_name_purple</string>
     <string name="bundle_name_rainbow7" translatable="false">@string/rainbow_color_name_magenta</string>
+    <string name="bundle_name_monochromatic" translatable="false">@string/monochromatic_name</string>
 
     <string name="color_style_rainbow1" translatable="false">RAINBOW</string>
     <string name="color_style_rainbow2" translatable="false">RAINBOW</string>
@@ -39,4 +41,5 @@
     <string name="color_style_rainbow5" translatable="false">RAINBOW</string>
     <string name="color_style_rainbow6" translatable="false">RAINBOW</string>
     <string name="color_style_rainbow7" translatable="false">RAINBOW</string>
+    <string name="color_style_monochromatic" translatable="false">MONOCHROMATIC</string>
 </resources>
