diff --git a/android-car-lib/Android.mk b/android-car-lib/Android.mk
new file mode 100644
index 0000000..a7cd0b3
--- /dev/null
+++ b/android-car-lib/Android.mk
@@ -0,0 +1,25 @@
+# Copyright (C) 2015 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.
+#
+#
+
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_AAPT2_ONLY := true
+
+LOCAL_PREBUILT_STATIC_JAVA_LIBRARIES := \
+        android-car:android-car.aar
+
+include $(BUILD_MULTI_PREBUILT)
diff --git a/android-car-lib/android-car-lib.mk b/android-car-lib/android-car-lib.mk
new file mode 100644
index 0000000..419daab
--- /dev/null
+++ b/android-car-lib/android-car-lib.mk
@@ -0,0 +1,53 @@
+#
+# Include this make file to build your application with car ui.
+# This only applied to app which is not CarActivity based but wants to use car-ui.
+#
+# Make sure to include it after you've set all your desired LOCAL variables.
+# Note that you must explicitly set your LOCAL_RESOURCE_DIR before including this file.
+#
+# For example:
+#
+#   LOCAL_RESOURCE_DIR := \
+#        $(LOCAL_PATH)/res
+#
+#   In your .mk file, include the items in the following order, to ensure the prebuilt
+#   static libraries are included in the correct order.
+#
+#   include vendor/auto/embedded/prebuilts/android-car-lib/car-lib.mk
+#   include $(BUILD_PACKAGE)
+#   include vendor/auto/embedded/prebuilts/android-car-lib/Android.mk
+
+# Check that LOCAL_RESOURCE_DIR is defined
+ifeq (,$(LOCAL_RESOURCE_DIR))
+$(error LOCAL_RESOURCE_DIR must be defined)
+endif
+
+LOCAL_STATIC_JAVA_AAR_LIBRARIES += android-car
+
+# Work around limitations of AAR prebuilts
+LOCAL_RESOURCE_DIR += packages/apps/Car/libs/android-car-lib/res
+
+# Include support-v7-appcompat, if not already included
+ifeq (,$(findstring android-support-v7-appcompat,$(LOCAL_STATIC_JAVA_LIBRARIES)))
+LOCAL_STATIC_ANDROID_LIBRARIES += android-support-v7-appcompat
+endif
+
+# Include support-v7-recyclerview, if not already included
+ifeq (,$(findstring android-support-v7-recyclerview,$(LOCAL_STATIC_JAVA_LIBRARIES)))
+LOCAL_STATIC_ANDROID_LIBRARIES += android-support-v7-recyclerview
+endif
+
+# Include support-v7-cardview, if not already included
+ifeq (,$(findstring android-support-v7-cardview,$(LOCAL_STATIC_JAVA_LIBRARIES)))
+LOCAL_STATIC_ANDROID_LIBRARIES += android-support-v7-cardview
+endif
+
+# Include support-design, if not already included
+ifeq (,$(findstring android-support-design,$(LOCAL_STATIC_JAVA_LIBRARIES)))
+LOCAL_STATIC_ANDROID_LIBRARIES += android-support-design
+endif
+
+# Include support-v4, if not already included
+ifeq (,$(findstring android-support-v4,$(LOCAL_STATIC_JAVA_LIBRARIES)))
+LOCAL_STATIC_ANDROID_LIBRARIES += android-support-v4
+endif
diff --git a/android-car-lib/android-car.aar b/android-car-lib/android-car.aar
new file mode 100644
index 0000000..ff03a9c
--- /dev/null
+++ b/android-car-lib/android-car.aar
Binary files differ
diff --git a/android-car-lib/car-release.aar b/android-car-lib/car-release.aar
new file mode 100644
index 0000000..ff03a9c
--- /dev/null
+++ b/android-car-lib/car-release.aar
Binary files differ
diff --git a/android-car-lib/res/anim/fade_in_trans_left.xml b/android-car-lib/res/anim/fade_in_trans_left.xml
new file mode 100644
index 0000000..2d6bab5
--- /dev/null
+++ b/android-car-lib/res/anim/fade_in_trans_left.xml
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2017 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.
+-->
+<set xmlns:android="http://schemas.android.com/apk/res/android"
+     android:duration="@android:integer/config_shortAnimTime">
+    <translate
+        android:interpolator="@android:interpolator/decelerate_quint"
+        android:fromXDelta="-10%p"
+        android:toXDelta="0" />
+
+    <alpha
+        android:fromAlpha="0.2"
+        android:toAlpha="1"
+        android:interpolator="@android:interpolator/decelerate_quint" />
+</set>
diff --git a/android-car-lib/res/anim/fade_in_trans_left_layout_anim.xml b/android-car-lib/res/anim/fade_in_trans_left_layout_anim.xml
new file mode 100644
index 0000000..e7660db
--- /dev/null
+++ b/android-car-lib/res/anim/fade_in_trans_left_layout_anim.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2017 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.
+-->
+<layoutAnimation
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:animation="@anim/fade_in_trans_left"
+    android:delay="0%"
+    android:animationOrder="normal" />
diff --git a/android-car-lib/res/anim/fade_in_trans_right.xml b/android-car-lib/res/anim/fade_in_trans_right.xml
new file mode 100644
index 0000000..5cbeb59
--- /dev/null
+++ b/android-car-lib/res/anim/fade_in_trans_right.xml
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2017 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.
+-->
+<set xmlns:android="http://schemas.android.com/apk/res/android"
+     android:duration="@android:integer/config_shortAnimTime">
+    <translate
+        android:interpolator="@android:interpolator/decelerate_quint"
+        android:fromXDelta="10%p"
+        android:toXDelta="0" />
+
+    <alpha
+        android:fromAlpha="0.2"
+        android:toAlpha="1"
+        android:interpolator="@android:interpolator/decelerate_quint" />
+</set>
diff --git a/android-car-lib/res/anim/fade_in_trans_right_layout_anim.xml b/android-car-lib/res/anim/fade_in_trans_right_layout_anim.xml
new file mode 100644
index 0000000..b76de23
--- /dev/null
+++ b/android-car-lib/res/anim/fade_in_trans_right_layout_anim.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2017 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.
+-->
+<layoutAnimation
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:animation="@anim/fade_in_trans_right"
+    android:delay="0%"
+    android:animationOrder="normal" />
diff --git a/android-car-lib/res/anim/lock_out_message_bar.xml b/android-car-lib/res/anim/lock_out_message_bar.xml
new file mode 100644
index 0000000..e70a4ef
--- /dev/null
+++ b/android-car-lib/res/anim/lock_out_message_bar.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<set
+    xmlns:android="http://schemas.android.com/apk/res/android" >
+    <objectAnimator
+        android:duration="@integer/speed_bump_lock_out_duration_ms"
+        android:propertyName="pathData"
+        android:valueFrom="M 96.5,48.5 c 0.0,26.5096740723 -21.4903259277,48.0 -48.0,48.0 c 0.0,0.0 -384.0,0.0 -384.0,0.0 c -26.5096740723,0.0 -48.0,-21.4903259277 -48.0,-48.0 c 0.0,-26.5096740723 21.4903259277,-48.0 48.0,-48.0 c 0.0,0.0 384.0,0.0 384.0,0.0 c 26.5096740723,0.0 48.0,21.4903411865 48.0,48.0 Z"
+        android:valueTo="M 480.5,48.5 c 0.0,26.5096740723 -21.4903259277,48.0 -48.0,48.0 c 0.0,0.0 -384.0,0.0 -384.0,0.0 c -26.5096740723,0.0 -48.0,-21.4903259277 -48.0,-48.0 c 0.0,-26.5096740723 21.4903259277,-48.0 48.0,-48.0 c 0.0,0.0 384.0,0.0 384.0,0.0 c 26.5096740723,0.0 48.0,21.4903259277 48.0,48.0 Z"
+        android:valueType="pathType"
+        android:interpolator="@interpolator/speed_bump_interpolator" />
+</set>
diff --git a/android-car-lib/res/anim/lock_out_message_bg_color_change.xml b/android-car-lib/res/anim/lock_out_message_bg_color_change.xml
new file mode 100644
index 0000000..6d56ff4
--- /dev/null
+++ b/android-car-lib/res/anim/lock_out_message_bg_color_change.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<set
+    xmlns:android="http://schemas.android.com/apk/res/android" >
+    <objectAnimator
+        android:startOffset="@integer/speed_bump_lock_out_color_change_start_delay_ms"
+        android:duration="@integer/speed_bump_lock_out_color_change_ms"
+        android:propertyName="fillColor"
+        android:valueFrom="#FF029AE5"
+        android:valueTo="#FF26994B"
+        android:interpolator="@android:interpolator/linear" />
+</set>
diff --git a/android-car-lib/res/anim/lock_out_message_in.xml b/android-car-lib/res/anim/lock_out_message_in.xml
new file mode 100644
index 0000000..aae3d17
--- /dev/null
+++ b/android-car-lib/res/anim/lock_out_message_in.xml
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<set xmlns:android="http://schemas.android.com/apk/res/android">
+    <alpha
+        android:fromAlpha="0"
+        android:toAlpha="1.0"
+        android:fillEnabled="true"
+        android:fillBefore="true"
+        android:fillAfter="true"
+        android:interpolator="@android:interpolator/accelerate_quint"
+        android:duration="@integer/speed_bump_fade_duration_ms"/>
+    <translate
+        android:fromYDelta="100%"
+        android:toYDelta="0%"
+        android:fillEnabled="true"
+        android:fillBefore="true"
+        android:fillAfter="true"
+        android:interpolator="@android:interpolator/linear_out_slow_in"
+        android:duration="@integer/speed_bump_translate_y_duration_ms"/>
+</set>
diff --git a/android-car-lib/res/anim/lock_out_message_out.xml b/android-car-lib/res/anim/lock_out_message_out.xml
new file mode 100644
index 0000000..3044d0a
--- /dev/null
+++ b/android-car-lib/res/anim/lock_out_message_out.xml
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<!-- 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.
+-->
+<set xmlns:android="http://schemas.android.com/apk/res/android">
+    <alpha
+        android:fromAlpha="1.0"
+        android:toAlpha="0"
+        android:fillEnabled="true"
+        android:fillBefore="true"
+        android:fillAfter="true"
+        android:interpolator="@android:interpolator/accelerate_quint"
+        android:duration="@integer/speed_bump_fade_duration_ms"/>
+</set>
diff --git a/android-car-lib/res/drawable/car_action_button_activated_ring_foreground.xml b/android-car-lib/res/drawable/car_action_button_activated_ring_foreground.xml
new file mode 100644
index 0000000..cf9570b
--- /dev/null
+++ b/android-car-lib/res/drawable/car_action_button_activated_ring_foreground.xml
@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<selector
+    xmlns:android="http://schemas.android.com/apk/res/android">
+  <item
+      android:state_activated="true">
+    <shape
+        xmlns:android="http://schemas.android.com/apk/res/android"
+        android:shape="oval">
+      <stroke
+          android:color="@color/car_tint"
+          android:width="@dimen/car_action_bar_activation_ring_stroke_width">
+      </stroke>
+      <size
+          android:height="@dimen/car_action_bar_activation_ring_radius"
+          android:width="@dimen/car_action_bar_activation_ring_radius"/>
+    </shape>
+  </item>
+  <!--Yes, this is a load-bearing invisible circle.-->
+  <!--Android doesn't remeasure foregrounds when state_activated changes, -->
+  <!--so we need a default drawable with the same size as the one we actually want to draw-->
+  <item>
+    <shape
+        xmlns:android="http://schemas.android.com/apk/res/android"
+        android:shape="oval">
+      <stroke
+          android:color="#00000000"
+          android:width="@dimen/car_action_bar_activation_ring_stroke_width">
+      </stroke>
+      <size
+          android:height="@dimen/car_action_bar_activation_ring_radius"
+          android:width="@dimen/car_action_bar_activation_ring_radius"/>
+    </shape>
+  </item>
+</selector>
diff --git a/android-car-lib/res/drawable/car_action_button_background.xml b/android-car-lib/res/drawable/car_action_button_background.xml
new file mode 100644
index 0000000..27e97e3
--- /dev/null
+++ b/android-car-lib/res/drawable/car_action_button_background.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<inset xmlns:android="http://schemas.android.com/apk/res/android"
+    android:inset="@dimen/car_action_button_ripple_inset" >
+    <ripple android:color="@color/car_card_ripple_background" />
+</inset>
diff --git a/android-car-lib/res/drawable/car_borderless_button_text_color.xml b/android-car-lib/res/drawable/car_borderless_button_text_color.xml
new file mode 100644
index 0000000..27f79f0
--- /dev/null
+++ b/android-car-lib/res/drawable/car_borderless_button_text_color.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2017 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.
+-->
+<!-- Default text colors for car buttons when enabled/disabled. -->
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:color="@color/car_grey_700" android:state_enabled="false"/>
+    <item android:color="?android:attr/colorButtonNormal"/>
+</selector>
diff --git a/android-car-lib/res/drawable/car_button_background.xml b/android-car-lib/res/drawable/car_button_background.xml
new file mode 100644
index 0000000..58aa739
--- /dev/null
+++ b/android-car-lib/res/drawable/car_button_background.xml
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2017 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.
+-->
+<!-- Default background styles for car buttons when enabled/disabled. -->
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:state_enabled="false">
+        <shape android:shape="rectangle">
+            <corners android:radius="@dimen/car_button_radius"/>
+            <solid android:color="@color/car_grey_300"/>
+        </shape>
+    </item>
+    <item>
+        <shape android:shape="rectangle">
+            <corners android:radius="@dimen/car_button_radius"/>
+            <solid android:color="?android:attr/colorButtonNormal"/>
+        </shape>
+    </item>
+</selector>
diff --git a/android-car-lib/res/drawable/car_button_text_color.xml b/android-car-lib/res/drawable/car_button_text_color.xml
new file mode 100644
index 0000000..bb8c681
--- /dev/null
+++ b/android-car-lib/res/drawable/car_button_text_color.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2017 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.
+-->
+<!-- Default text colors for car buttons when enabled/disabled. -->
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:color="@color/car_grey_700" android:state_enabled="false"/>
+    <item android:color="@color/car_action1"/>
+</selector>
diff --git a/android-car-lib/res/drawable/car_card_background.xml b/android-car-lib/res/drawable/car_card_background.xml
new file mode 100644
index 0000000..7caa2ff
--- /dev/null
+++ b/android-car-lib/res/drawable/car_card_background.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2017 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  -->
+<shape xmlns:android="http://schemas.android.com/apk/res/android">
+    <solid android:color="@color/car_card"/>
+</shape>
\ No newline at end of file
diff --git a/android-car-lib/res/drawable/car_card_ripple_background.xml b/android-car-lib/res/drawable/car_card_ripple_background.xml
new file mode 100644
index 0000000..ca20e0f
--- /dev/null
+++ b/android-car-lib/res/drawable/car_card_ripple_background.xml
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2017 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.
+  -->
+<ripple
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:color="@color/car_card_ripple_background">
+    <item
+        android:id="@android:id/mask"
+        android:drawable="@android:color/white" />
+</ripple>
diff --git a/android-car-lib/res/drawable/car_card_ripple_background_day.xml b/android-car-lib/res/drawable/car_card_ripple_background_day.xml
new file mode 100644
index 0000000..880ff7a
--- /dev/null
+++ b/android-car-lib/res/drawable/car_card_ripple_background_day.xml
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2017 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.
+  -->
+<ripple
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:color="@color/car_card_ripple_background_dark">
+    <item
+        android:id="@android:id/mask"
+        android:drawable="@android:color/white" />
+</ripple>
diff --git a/android-car-lib/res/drawable/car_card_ripple_background_inverse.xml b/android-car-lib/res/drawable/car_card_ripple_background_inverse.xml
new file mode 100644
index 0000000..e063e2c
--- /dev/null
+++ b/android-car-lib/res/drawable/car_card_ripple_background_inverse.xml
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2017 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.
+  -->
+<ripple
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:color="@color/car_card_ripple_background_inverse" >
+    <item
+        android:id="@android:id/mask"
+        android:drawable="@android:color/white" />
+</ripple>
diff --git a/android-car-lib/res/drawable/car_card_ripple_background_night.xml b/android-car-lib/res/drawable/car_card_ripple_background_night.xml
new file mode 100644
index 0000000..5d4f2c6
--- /dev/null
+++ b/android-car-lib/res/drawable/car_card_ripple_background_night.xml
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2017 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.
+  -->
+<ripple
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:color="@color/car_card_ripple_background_light">
+    <item
+        android:id="@android:id/mask"
+        android:drawable="@android:color/white" />
+</ripple>
diff --git a/android-car-lib/res/drawable/car_card_rounded_background.xml b/android-car-lib/res/drawable/car_card_rounded_background.xml
new file mode 100644
index 0000000..594705b
--- /dev/null
+++ b/android-car-lib/res/drawable/car_card_rounded_background.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2017 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  -->
+<shape xmlns:android="http://schemas.android.com/apk/res/android">
+    <solid android:color="@color/car_card"/>
+    <corners
+        android:radius="@dimen/car_radius_3"/>
+</shape>
\ No newline at end of file
diff --git a/android-car-lib/res/drawable/car_card_rounded_bottom_background.xml b/android-car-lib/res/drawable/car_card_rounded_bottom_background.xml
new file mode 100644
index 0000000..35dba13
--- /dev/null
+++ b/android-car-lib/res/drawable/car_card_rounded_bottom_background.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2017 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  -->
+<shape xmlns:android="http://schemas.android.com/apk/res/android">
+    <solid android:color="@color/car_card"/>
+    <corners
+        android:bottomRightRadius="@dimen/car_radius_3"
+        android:bottomLeftRadius="@dimen/car_radius_3"/>
+</shape>
\ No newline at end of file
diff --git a/android-car-lib/res/drawable/car_card_rounded_top_background.xml b/android-car-lib/res/drawable/car_card_rounded_top_background.xml
new file mode 100644
index 0000000..dfb5622
--- /dev/null
+++ b/android-car-lib/res/drawable/car_card_rounded_top_background.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2017 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  -->
+<shape xmlns:android="http://schemas.android.com/apk/res/android">
+    <solid android:color="@color/car_card"/>
+    <corners
+        android:topRightRadius="@dimen/car_radius_3"
+        android:topLeftRadius="@dimen/car_radius_3"/>
+</shape>
\ No newline at end of file
diff --git a/android-car-lib/res/drawable/car_drawer_list_item_background.xml b/android-car-lib/res/drawable/car_drawer_list_item_background.xml
new file mode 100644
index 0000000..c5fc36b
--- /dev/null
+++ b/android-car-lib/res/drawable/car_drawer_list_item_background.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2017 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.
+  -->
+<ripple xmlns:android="http://schemas.android.com/apk/res/android"
+    android:color="@color/car_card_ripple_background">
+    <item android:id="@android:id/mask">
+        <color android:color="#ffffffff" />
+    </item>
+</ripple>
diff --git a/android-car-lib/res/drawable/car_list_divider.xml b/android-car-lib/res/drawable/car_list_divider.xml
new file mode 100644
index 0000000..14a5ce1
--- /dev/null
+++ b/android-car-lib/res/drawable/car_list_divider.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2014 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.
+-->
+
+<!-- Drawable of dividers used in lists -->
+<shape xmlns:android="http://schemas.android.com/apk/res/android">
+    <size android:height="@dimen/car_list_divider_height"/>
+    <solid android:color="@color/car_list_divider"/>
+</shape>
\ No newline at end of file
diff --git a/android-car-lib/res/drawable/car_list_divider_dark.xml b/android-car-lib/res/drawable/car_list_divider_dark.xml
new file mode 100644
index 0000000..4760623
--- /dev/null
+++ b/android-car-lib/res/drawable/car_list_divider_dark.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+
+<!-- Drawable of dividers used in lists -->
+<shape xmlns:android="http://schemas.android.com/apk/res/android">
+  <size android:height="@dimen/car_list_divider_height"/>
+  <solid android:color="@color/car_list_divider_dark"/>
+</shape>
diff --git a/android-car-lib/res/drawable/car_list_divider_light.xml b/android-car-lib/res/drawable/car_list_divider_light.xml
new file mode 100644
index 0000000..07b52dd
--- /dev/null
+++ b/android-car-lib/res/drawable/car_list_divider_light.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+
+<!-- Drawable of dividers used in lists -->
+<shape xmlns:android="http://schemas.android.com/apk/res/android">
+  <size android:height="@dimen/car_list_divider_height"/>
+  <solid android:color="@color/car_list_divider_light"/>
+</shape>
diff --git a/android-car-lib/res/drawable/car_scrollbar_thumb.xml b/android-car-lib/res/drawable/car_scrollbar_thumb.xml
new file mode 100644
index 0000000..42aaebf
--- /dev/null
+++ b/android-car-lib/res/drawable/car_scrollbar_thumb.xml
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ 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
+  -->
+
+<shape
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:shape="rectangle">
+    <solid android:color="@color/car_scrollbar_thumb" />
+    <corners android:radius="@dimen/car_radius_5"/>
+</shape>
diff --git a/android-car-lib/res/drawable/car_seekbar_thumb.xml b/android-car-lib/res/drawable/car_seekbar_thumb.xml
new file mode 100644
index 0000000..a5c4910
--- /dev/null
+++ b/android-car-lib/res/drawable/car_seekbar_thumb.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ 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
+  -->
+
+<shape
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:shape="oval">
+    <solid android:color="@color/car_accent" />
+    <size
+        android:width="@dimen/car_seekbar_thumb_size"
+        android:height="@dimen/car_seekbar_thumb_size" />
+</shape>
\ No newline at end of file
diff --git a/android-car-lib/res/drawable/car_seekbar_track.xml b/android-car-lib/res/drawable/car_seekbar_track.xml
new file mode 100644
index 0000000..05700c2
--- /dev/null
+++ b/android-car-lib/res/drawable/car_seekbar_track.xml
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ 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
+  -->
+
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:id="@android:id/background">
+        <shape android:shape="line">
+            <stroke
+                android:width="@dimen/car_seekbar_height"
+                android:color="@color/car_seekbar_track_background" />
+        </shape>
+    </item>
+    <item android:id="@android:id/progress">
+        <clip>
+            <shape android:shape="line">
+                <stroke
+                    android:width="@dimen/car_seekbar_height"
+                    android:color="@color/car_accent" />
+            </shape>
+        </clip>
+    </item>
+</layer-list>
\ No newline at end of file
diff --git a/android-car-lib/res/drawable/ic_down.xml b/android-car-lib/res/drawable/ic_down.xml
new file mode 100644
index 0000000..cd486c1
--- /dev/null
+++ b/android-car-lib/res/drawable/ic_down.xml
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ 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.
+  -->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+        android:width="76dp"
+        android:height="76dp"
+        android:viewportWidth="76.0"
+        android:viewportHeight="76.0">
+    <path
+        android:pathData="M38,0.96C17.01,0.96 0,17.75 0,38.47C0,59.18 17.01,75.97 38,75.97C58.99,75.97 76,59.18 76,38.47C76,17.75 58.99,0.96 38,0.96M38,3.3C57.64,3.3 73.62,19.08 73.62,38.47C73.62,57.85 57.64,73.63 38,73.63C18.36,73.63 2.38,57.86 2.38,38.47C2.38,19.08 18.36,3.3 38,3.3"
+        android:strokeColor="#00000000"
+        android:fillColor="#212121"
+        android:strokeWidth="1"/>
+    <path
+        android:pathData="M26.63,31.09l11.37,11.08l11.37,-11.08l3.5,3.42l-14.87,14.5l-14.87,-14.5z"
+        android:strokeColor="#00000000"
+        android:fillColor="#212121"
+        android:strokeWidth="1"/>
+</vector>
diff --git a/android-car-lib/res/drawable/ic_list_view_disable.xml b/android-car-lib/res/drawable/ic_list_view_disable.xml
new file mode 100644
index 0000000..8649423
--- /dev/null
+++ b/android-car-lib/res/drawable/ic_list_view_disable.xml
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2017 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="176dp"
+        android:height="176dp"
+        android:viewportWidth="176.0"
+        android:viewportHeight="176.0">
+    <path
+        android:pathData="M88.99,55.55l15.71,15.71l46.13,0l0,-15.71z"
+        android:fillColor="#212121"/>
+    <path
+        android:pathData="M25.19,119.06h66.5v15.71h-66.5z"
+        android:fillColor="#212121"/>
+    <path
+        android:pathData="M114.58,103.35l-15.71,-15.71l-0.12,0l-16.38,-16.38l0.12,0l-15.71,-15.71l-0.12,0l-30.29,-30.29l-11.11,11.11l19.19,19.18l-19.28,0l0,15.71l34.98,0l16.39,16.38l-51.37,0l0,15.71l67.08,0l47.38,47.39l11.11,-11.11l-36.28,-36.28z"
+        android:fillColor="#212121"/>
+    <path
+        android:pathData="M136.79,103.35l14.04,0l0,-15.71l-29.74,0z"
+        android:fillColor="#212121"/>
+</vector>
diff --git a/android-car-lib/res/drawable/ic_overflow.xml b/android-car-lib/res/drawable/ic_overflow.xml
new file mode 100644
index 0000000..eda306c
--- /dev/null
+++ b/android-car-lib/res/drawable/ic_overflow.xml
@@ -0,0 +1,45 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="56dp"
+    android:height="56dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+
+    <group
+            android:translateX="-0.750000"
+            android:translateY="-0.750000">
+        <path
+            android:strokeWidth="1"
+            android:pathData="M 0.75 24.75 L 24.75 24.75 L 24.75 0.75 L 0.75 0.75 Z" />
+        <path
+            android:fillColor="#000000"
+            android:strokeWidth="1"
+            android:pathData="M12.75,10.1666667 C13.4604167,10.1666667 14.0416667,9.58541667 14.0416667,8.875
+C14.0416667,8.16458333 13.4604167,7.58333333 12.75,7.58333333
+C12.0395833,7.58333333 11.4583333,8.16458333 11.4583333,8.875
+C11.4583333,9.58541667 12.0395833,10.1666667 12.75,10.1666667 L12.75,10.1666667
+Z M12.75,11.4583333 C12.0395833,11.4583333 11.4583333,12.0395833
+11.4583333,12.75 C11.4583333,13.4604167 12.0395833,14.0416667 12.75,14.0416667
+C13.4604167,14.0416667 14.0416667,13.4604167 14.0416667,12.75
+C14.0416667,12.0395833 13.4604167,11.4583333 12.75,11.4583333 L12.75,11.4583333
+Z M12.75,15.3333333 C12.0395833,15.3333333 11.4583333,15.9145833
+11.4583333,16.625 C11.4583333,17.3354167 12.0395833,17.9166667 12.75,17.9166667
+C13.4604167,17.9166667 14.0416667,17.3354167 14.0416667,16.625
+C14.0416667,15.9145833 13.4604167,15.3333333 12.75,15.3333333 L12.75,15.3333333
+Z" />
+    </group>
+</vector>
diff --git a/android-car-lib/res/drawable/ic_up.xml b/android-car-lib/res/drawable/ic_up.xml
new file mode 100644
index 0000000..ec18410
--- /dev/null
+++ b/android-car-lib/res/drawable/ic_up.xml
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ 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.
+  -->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+        android:width="76dp"
+        android:height="76dp"
+        android:viewportWidth="76.0"
+        android:viewportHeight="76.0">
+    <path
+        android:pathData="M38,75.04C58.99,75.04 76,58.27 76,37.57C76,16.88 58.99,0.11 38,0.11C17.01,0.11 0,16.88 0,37.57C0,58.27 17.01,75.04 38,75.04M38,72.7C18.36,72.7 2.38,56.94 2.38,37.57C2.38,18.21 18.36,2.45 38,2.45C57.64,2.45 73.62,18.21 73.62,37.57C73.62,56.94 57.64,72.7 38,72.7"
+        android:strokeColor="#00000000"
+        android:fillColor="#212121"
+        android:strokeWidth="1"/>
+    <path
+        android:pathData="M49.37,44.9l-11.37,-11.08l-11.37,11.08l-3.5,-3.42l14.87,-14.5l14.87,14.5z"
+        android:strokeColor="#00000000"
+        android:fillColor="#212121"
+        android:strokeWidth="1"/>
+</vector>
diff --git a/android-car-lib/res/drawable/lock_out_message_animation.xml b/android-car-lib/res/drawable/lock_out_message_animation.xml
new file mode 100644
index 0000000..42cea41
--- /dev/null
+++ b/android-car-lib/res/drawable/lock_out_message_animation.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<animated-vector
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:drawable="@drawable/lock_out_message_background" >
+    <target
+        android:name="bar_mask"
+        android:animation="@anim/lock_out_message_bar" />
+    <target
+        android:name="bar_path"
+        android:animation="@anim/lock_out_message_bg_color_change" />
+</animated-vector>
diff --git a/android-car-lib/res/drawable/lock_out_message_background.xml b/android-car-lib/res/drawable/lock_out_message_background.xml
new file mode 100644
index 0000000..26b559b
--- /dev/null
+++ b/android-car-lib/res/drawable/lock_out_message_background.xml
@@ -0,0 +1,62 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<vector
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="480dp"
+    android:viewportWidth="480"
+    android:height="96dp"
+    android:viewportHeight="96" >
+    <group
+        android:name="base"
+        android:translateX="240"
+        android:translateY="48"
+        android:scaleX="0.994"
+        android:scaleY="0.994" >
+        <group
+            android:name="base_pivot"
+            android:translateX="-240"
+            android:translateY="-47" >
+            <group
+                android:name="base"
+                android:scaleY="0.99" >
+                <path
+                    android:name="base_path"
+                    android:pathData="M 480.0,48.0 c 0.0,26.5096740723 -21.4903259277,48.0 -48.0,48.0 c 0.0,0.0 -384.0,0.0 -384.0,0.0 c -26.5096740723,0.0 -48.0,-21.4903259277 -48.0,-48.0 c 0.0,-26.5096740723 21.4903259277,-48.0 48.0,-48.0 c 0.0,0.0 384.0,0.0 384.0,0.0 c 26.5096740723,0.0 48.0,21.4903259277 48.0,48.0 Z"
+                    android:fillColor="@color/speed_bump_background" />
+            </group>
+        </group>
+    </group>
+    <group
+        android:name="bar"
+        android:translateX="240"
+        android:translateY="48" >
+        <group
+            android:name="bar_pivot"
+            android:translateX="-240"
+            android:translateY="-48" >
+            <clip-path
+                android:name="bar_mask"
+                android:pathData="M 96.5,48.5 c 0.0,26.5096740723 -21.4903259277,48.0 -48.0,48.0 c 0.0,0.0 -384.0,0.0 -384.0,0.0 c -26.5096740723,0.0 -48.0,-21.4903259277 -48.0,-48.0 c 0.0,-26.5096740723 21.4903259277,-48.0 48.0,-48.0 c 0.0,0.0 384.0,0.0 384.0,0.0 c 26.5096740723,0.0 48.0,21.4903411865 48.0,48.0 Z" />
+            <group
+                android:name="base" >
+                <path
+                    android:name="bar_path"
+                    android:pathData="M 480.0,48.0 c 0.0,26.5096740723 -21.4903259277,48.0 -48.0,48.0 c 0.0,0.0 -384.0,0.0 -384.0,0.0 c -26.5096740723,0.0 -48.0,-21.4903259277 -48.0,-48.0 c 0.0,-26.5096740723 21.4903259277,-48.0 48.0,-48.0 c 0.0,0.0 384.0,0.0 384.0,0.0 c 26.5096740723,0.0 48.0,21.4903259277 48.0,48.0 Z"
+                    android:fillColor="#FF029AE5" />
+            </group>
+        </group>
+    </group>
+</vector>
diff --git a/android-car-lib/res/drawable/speed_bump_scrim.xml b/android-car-lib/res/drawable/speed_bump_scrim.xml
new file mode 100644
index 0000000..aacea49
--- /dev/null
+++ b/android-car-lib/res/drawable/speed_bump_scrim.xml
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+       android:shape="rectangle" >
+    <gradient
+        android:type="linear"
+        android:startColor="@android:color/transparent"
+        android:endColor="#8d000000"
+        android:angle="270"/>
+</shape>
diff --git a/android-car-lib/res/interpolator/speed_bump_interpolator.xml b/android-car-lib/res/interpolator/speed_bump_interpolator.xml
new file mode 100644
index 0000000..ec7e694
--- /dev/null
+++ b/android-car-lib/res/interpolator/speed_bump_interpolator.xml
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<pathInterpolator
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:pathData="M 0.0,0.0 c 1.0,0.535553908162 0.961348094524,0.999999995867 1.0,1.0" />
diff --git a/android-car-lib/res/layout/action_bar.xml b/android-car-lib/res/layout/action_bar.xml
new file mode 100644
index 0000000..431a2a8
--- /dev/null
+++ b/android-car-lib/res/layout/action_bar.xml
@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<androidx.cardview.widget.CardView
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:id="@+id/action_bar_wrapper"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:elevation="@dimen/car_action_bar_elevation"
+    app:cardCornerRadius="@dimen/car_radius_3">
+
+    <LinearLayout
+        android:id="@+id/rows_container"
+        android:orientation="vertical"
+        android:animateLayoutChanges="true"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content">
+
+        <LinearLayout
+            android:orientation="horizontal"
+            android:visibility="gone"
+            android:clipChildren="false"
+            android:layout_width="match_parent"
+            android:layout_height="@dimen/car_action_bar_height">
+        </LinearLayout>
+
+        <LinearLayout
+            android:orientation="horizontal"
+            android:clipChildren="false"
+            android:layout_width="match_parent"
+            android:layout_height="@dimen/car_action_bar_height">
+        </LinearLayout>
+
+    </LinearLayout>
+
+</androidx.cardview.widget.CardView>
\ No newline at end of file
diff --git a/android-car-lib/res/layout/action_bar_button.xml b/android-car-lib/res/layout/action_bar_button.xml
new file mode 100644
index 0000000..e9d2370
--- /dev/null
+++ b/android-car-lib/res/layout/action_bar_button.xml
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<ImageButton style="@style/Widget.Car.Button.ActionBar" />
diff --git a/android-car-lib/res/layout/action_bar_slot.xml b/android-car-lib/res/layout/action_bar_slot.xml
new file mode 100644
index 0000000..804e356
--- /dev/null
+++ b/android-car-lib/res/layout/action_bar_slot.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<FrameLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="0dp"
+    android:layout_height="@dimen/car_action_bar_button_height"
+    android:layout_weight="1"
+    android:visibility="visible"
+    android:foregroundGravity="center"
+    android:clipChildren="false"
+    android:foreground="@drawable/car_action_button_activated_ring_foreground">
+</FrameLayout>
\ No newline at end of file
diff --git a/android-car-lib/res/layout/car_alert_dialog.xml b/android-car-lib/res/layout/car_alert_dialog.xml
new file mode 100644
index 0000000..d9b52a5
--- /dev/null
+++ b/android-car-lib/res/layout/car_alert_dialog.xml
@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+
+<!-- Note: the width is 0dp because ColumnCardView will automatically set a width based
+     on the number of columns it should take up. See ColumnCardView for more details. -->
+<androidx.car.widget.ColumnCardView
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:layout_gravity="center"
+    android:layout_width="0dp"
+    android:layout_height="wrap_content"
+    android:elevation="@dimen/car_dialog_elevation"
+    app:cardBackgroundColor="?attr/dialogBackgroundColor"
+    app:cardCornerRadius="@dimen/car_radius_3">
+
+    <LinearLayout
+        android:id="@+id/content_view"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_marginStart="@dimen/car_keyline_1"
+        android:layout_marginEnd="@dimen/car_keyline_1"
+        android:paddingTop="@dimen/car_padding_4"
+        android:paddingBottom="@dimen/car_padding_4"
+        android:orientation="vertical">
+
+        <TextView
+            android:id="@+id/title"
+            android:layout_width="wrap_content"
+            android:layout_height="@dimen/car_dialog_header_height"
+            android:gravity="center_vertical|start"
+            android:visibility="gone"
+            style="?attr/dialogTitleStyle" />
+
+        <TextView
+            android:id="@+id/body"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:visibility="gone"
+            style="?attr/dialogBodyStyle" />
+
+        <LinearLayout
+            android:id="@+id/button_panel"
+            android:layout_width="match_parent"
+            android:layout_height="@dimen/car_dialog_action_bar_height"
+            android:layout_marginTop="@dimen/car_padding_2"
+            android:gravity="center_vertical"
+            android:orientation="horizontal"
+            android:visibility="gone">
+
+            <Button
+                android:id="@+id/positive_button"
+                android:layout_marginEnd="@dimen/car_padding_4"
+                android:layout_width="wrap_content"
+                android:minWidth="0dp"
+                android:padding="0dp"
+                android:textColor="@color/car_accent"
+                android:visibility="gone"
+                style="?attr/dialogButtonStyle" />
+
+            <Button
+                android:id="@+id/negative_button"
+                android:layout_width="wrap_content"
+                android:minWidth="0dp"
+                android:padding="0dp"
+                android:textColor="@color/car_accent"
+                android:visibility="gone"
+                style="?attr/dialogButtonStyle" />
+        </LinearLayout>
+    </LinearLayout>
+</androidx.car.widget.ColumnCardView>
diff --git a/android-car-lib/res/layout/car_drawer.xml b/android-car-lib/res/layout/car_drawer.xml
new file mode 100644
index 0000000..0629862
--- /dev/null
+++ b/android-car-lib/res/layout/car_drawer.xml
@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2017 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.
+-->
+<androidx.car.moderator.SpeedBumpView
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:id="@+id/drawer_content"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:layout_marginEnd="@dimen/car_drawer_margin_end"
+    android:background="?attr/drawerBackgroundColor"
+    android:paddingTop="@dimen/car_app_bar_height" >
+
+  <androidx.car.widget.PagedListView
+      android:id="@+id/drawer_list"
+      android:layout_width="match_parent"
+      android:layout_height="match_parent"
+      app:listEndMargin="@dimen/car_drawer_margin_end"
+      app:gutter="start"
+      style="?attr/drawerListStyle" />
+
+  <ProgressBar
+      android:id="@+id/drawer_progress"
+      android:layout_width="@dimen/car_drawer_progress_bar_size"
+      android:layout_height="@dimen/car_drawer_progress_bar_size"
+      android:layout_gravity="center"
+      android:indeterminate="true"
+      android:visibility="gone" />
+</androidx.car.moderator.SpeedBumpView>
diff --git a/android-car-lib/res/layout/car_drawer_activity.xml b/android-car-lib/res/layout/car_drawer_activity.xml
new file mode 100644
index 0000000..1648d09
--- /dev/null
+++ b/android-car-lib/res/layout/car_drawer_activity.xml
@@ -0,0 +1,56 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2017 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.
+-->
+<androidx.coordinatorlayout.widget.CoordinatorLayout
+    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="match_parent">
+
+    <androidx.drawerlayout.widget.DrawerLayout
+        android:id="@+id/drawer_layout"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent">
+
+        <!-- The main content view. Fragments will be added here. -->
+      <androidx.car.moderator.SpeedBumpView
+            android:id="@+id/content_frame"
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            app:layout_behavior="@string/appbar_scrolling_view_behavior" />
+
+        <include
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:layout_gravity="start"
+            layout="@layout/car_drawer" />
+    </androidx.drawerlayout.widget.DrawerLayout>
+
+    <android.support.design.widget.AppBarLayout
+        android:id="@+id/appbar"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:fitsSystemWindows="true">
+        <!-- The min height of the Toolbar needs to be set to ensure that the icons in it
+             are vertically centered. -->
+        <androidx.car.widget.ClickThroughToolbar
+            android:id="@+id/car_toolbar"
+            android:layout_width="match_parent"
+            android:layout_height="@dimen/car_app_bar_height"
+            android:layout_gravity="center_vertical"
+            android:minHeight="@dimen/car_app_bar_height"
+            style="@style/Widget.Car.Toolbar" />
+    </android.support.design.widget.AppBarLayout>
+</androidx.coordinatorlayout.widget.CoordinatorLayout>
diff --git a/android-car-lib/res/layout/car_drawer_list_item_empty.xml b/android-car-lib/res/layout/car_drawer_list_item_empty.xml
new file mode 100644
index 0000000..d078a32
--- /dev/null
+++ b/android-car-lib/res/layout/car_drawer_list_item_empty.xml
@@ -0,0 +1,45 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2017 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:id="@+id/container"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:layout_marginStart="16dp"
+    android:focusable="false"
+    android:orientation="vertical"
+    android:background="@drawable/car_drawer_list_item_background" >
+    <FrameLayout
+        android:id="@+id/icon_container"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:visibility="visible">
+        <ImageView
+            android:id="@+id/icon"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_gravity="center_horizontal"
+            android:layout_marginTop="48dp"
+            android:layout_marginBottom="22dp" />
+    </FrameLayout>
+    <TextView
+        android:id="@+id/title"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_marginEnd="16dp"
+        android:gravity="center"
+        android:textAppearance="?attr/drawerItemTitleTextAppearance" />
+</LinearLayout>
diff --git a/android-car-lib/res/layout/car_drawer_list_item_normal.xml b/android-car-lib/res/layout/car_drawer_list_item_normal.xml
new file mode 100644
index 0000000..a400c5a
--- /dev/null
+++ b/android-car-lib/res/layout/car_drawer_list_item_normal.xml
@@ -0,0 +1,59 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2017 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="@dimen/car_double_line_list_item_height"
+    android:focusable="true"
+    android:orientation="horizontal"
+    android:background="@drawable/car_drawer_list_item_background" >
+    <ImageView
+        android:id="@+id/icon"
+        android:layout_width="@dimen/car_drawer_list_item_icon_size"
+        android:layout_height="@dimen/car_drawer_list_item_icon_size"
+        android:layout_marginEnd="@dimen/car_drawer_list_item_icon_end_margin"
+        android:layout_gravity="center_vertical"
+        android:scaleType="centerCrop" />
+    <LinearLayout
+        android:id="@+id/text_container"
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:layout_weight="1"
+        android:layout_gravity="center_vertical"
+        android:orientation="vertical" >
+        <TextView
+            android:id="@+id/title"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_marginBottom="@dimen/car_text_vertical_margin"
+            android:maxLines="1"
+            android:textAppearance="?attr/drawerItemTitleTextAppearance" />
+        <TextView
+            android:id="@+id/text"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:ellipsize="end"
+            android:maxLines="1"
+            android:textAppearance="?attr/drawerItemBodyTextAppearance" />
+    </LinearLayout>
+    <ImageView
+        android:id="@+id/end_icon"
+        android:layout_width="@dimen/car_drawer_list_item_end_icon_size"
+        android:layout_height="@dimen/car_drawer_list_item_end_icon_size"
+        android:scaleType="fitCenter"
+        android:layout_marginEnd="@dimen/car_drawer_list_item_end_margin"
+        android:layout_gravity="center_vertical" />
+</LinearLayout>
diff --git a/android-car-lib/res/layout/car_drawer_list_item_small.xml b/android-car-lib/res/layout/car_drawer_list_item_small.xml
new file mode 100644
index 0000000..7ccf72b
--- /dev/null
+++ b/android-car-lib/res/layout/car_drawer_list_item_small.xml
@@ -0,0 +1,46 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2017 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="@dimen/car_single_line_list_item_height"
+    android:focusable="true"
+    android:orientation="horizontal"
+    android:background="@drawable/car_drawer_list_item_background" >
+    <ImageView
+        android:id="@+id/icon"
+        android:layout_width="@dimen/car_drawer_list_item_small_icon_size"
+        android:layout_height="@dimen/car_drawer_list_item_small_icon_size"
+        android:layout_marginEnd="@dimen/car_drawer_list_item_icon_end_margin"
+        android:layout_gravity="center_vertical"
+        android:scaleType="centerCrop" />
+    <TextView
+        android:id="@+id/title"
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:layout_weight="1"
+        android:layout_gravity="center_vertical"
+        android:layout_marginBottom="@dimen/car_text_vertical_margin"
+        android:maxLines="1"
+        android:textAppearance="?attr/drawerItemTitleTextAppearance" />
+    <ImageView
+        android:id="@+id/end_icon"
+        android:layout_width="@dimen/car_drawer_list_item_end_icon_size"
+        android:layout_height="@dimen/car_drawer_list_item_end_icon_size"
+        android:scaleType="fitCenter"
+        android:layout_marginEnd="@dimen/car_drawer_list_item_end_margin"
+        android:layout_gravity="center_vertical"/>
+</LinearLayout>
diff --git a/android-car-lib/res/layout/car_list_dialog.xml b/android-car-lib/res/layout/car_list_dialog.xml
new file mode 100644
index 0000000..c3ff1bf
--- /dev/null
+++ b/android-car-lib/res/layout/car_list_dialog.xml
@@ -0,0 +1,62 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+
+<FrameLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:id="@+id/container"
+    android:background="@android:color/transparent"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent" >
+
+    <!-- Note: the width is 0dp because ColumnCardView will automatically set a width based
+         on the number of columns it should take up. See ColumnCardView for more details. -->
+    <androidx.car.widget.ColumnCardView
+        android:layout_gravity="center"
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:layout_marginTop="@dimen/car_padding_4"
+        android:layout_marginBottom="@dimen/car_padding_4"
+        android:elevation="@dimen/car_dialog_elevation"
+        app:cardBackgroundColor="?attr/dialogBackgroundColor"
+        app:cardCornerRadius="@dimen/car_radius_3">
+
+        <!-- Hide the scrollbar for this PagedListView because it will be implemented by
+             @id/scrollbar. -->
+        <androidx.car.widget.PagedListView
+            android:id="@+id/list"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:theme="?attr/dialogListTheme"
+            app:gutter="none"
+            app:dividerStartMargin="@dimen/car_keyline_1"
+            app:dividerEndMargin="@dimen/car_keyline_1"
+            app:showPagedListViewDivider="true"
+            app:scrollBarEnabled="false" />
+    </androidx.car.widget.ColumnCardView>
+
+    <!-- Putting this as the last child for highest z-index. It is also clickable to reduce
+         the chance of clicks on the buttons accidentally dismissing the dialog. -->
+    <androidx.car.widget.PagedScrollBarView
+        android:id="@+id/scrollbar"
+        android:layout_width="@dimen/car_margin"
+        android:layout_height="match_parent"
+        android:layout_marginTop="@dimen/car_padding_4"
+        android:layout_marginBottom="@dimen/car_padding_4"
+        android:layout_gravity="start|top"
+        android:clickable="true"
+        android:visibility="invisible" />
+</FrameLayout>
diff --git a/android-car-lib/res/layout/car_list_item_seekbar_content.xml b/android-car-lib/res/layout/car_list_item_seekbar_content.xml
new file mode 100644
index 0000000..2e3b165
--- /dev/null
+++ b/android-car-lib/res/layout/car_list_item_seekbar_content.xml
@@ -0,0 +1,61 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ 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.
+  -->
+<RelativeLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/container"
+    android:layout_width="wrap_content"
+    android:layout_height="match_parent">
+
+    <!-- This layout should only be used by class SeekbarListItem, as it requires layout params
+         being set programmatically depending on item data/view configuration. -->
+
+    <!-- Primary Action. -->
+    <ImageView
+        android:id="@+id/primary_icon"
+        android:layout_width="@dimen/car_single_line_list_item_height"
+        android:layout_height="@dimen/car_single_line_list_item_height"/>
+
+    <!-- Slider and text. -->
+    <LinearLayout
+        android:id="@+id/seek_bar_container"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:orientation="vertical">
+        <TextView
+            android:id="@+id/text"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"/>
+        <SeekBar
+            android:id="@+id/seek_bar"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:splitTrack="false"
+            style="@style/Widget.Car.SeekBar"/>
+    </LinearLayout>
+
+    <!-- Supplemental action. -->
+    <ImageView
+        android:id="@+id/supplemental_icon"
+        android:layout_width="@dimen/car_primary_icon_size"
+        android:layout_height="@dimen/car_primary_icon_size"
+        android:scaleType="fitCenter"/>
+    <View
+        android:id="@+id/supplemental_icon_divider"
+        android:layout_width="@dimen/car_vertical_line_divider_width"
+        android:layout_height="@dimen/car_vertical_line_divider_height"
+        android:background="@color/car_list_divider"/>
+</RelativeLayout>
diff --git a/android-car-lib/res/layout/car_list_item_text_content.xml b/android-car-lib/res/layout/car_list_item_text_content.xml
new file mode 100644
index 0000000..a85a31e
--- /dev/null
+++ b/android-car-lib/res/layout/car_list_item_text_content.xml
@@ -0,0 +1,113 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2017 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.
+  -->
+<RelativeLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/container"
+    android:layout_width="wrap_content"
+    android:layout_height="match_parent"
+    android:foreground="@drawable/car_card_ripple_background">
+    <!-- Primary Action. -->
+    <ImageView
+        android:id="@+id/primary_icon"
+        android:layout_width="@dimen/car_single_line_list_item_height"
+        android:layout_height="@dimen/car_single_line_list_item_height"/>
+
+    <!-- Text. -->
+    <TextView
+        android:id="@+id/title"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:singleLine="true"
+        android:ellipsize="end"/>
+    <TextView
+        android:id="@+id/body"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"/>
+
+    <!-- Supplemental action(s) - only one of the following groups should be visible. -->
+    <!-- End icon with divider. -->
+    <View
+        android:id="@+id/supplemental_icon_divider"
+        android:layout_centerVertical="true"
+        android:layout_toStartOf="@id/supplemental_icon"
+        android:layout_marginEnd="@dimen/car_padding_4"
+        style="@style/CarListVerticalDivider"/>
+    <ImageView
+        android:id="@+id/supplemental_icon"
+        android:layout_centerVertical="true"
+        android:layout_width="@dimen/car_primary_icon_size"
+        android:layout_height="@dimen/car_primary_icon_size"
+        android:layout_alignParentEnd="true"
+        android:layout_marginEnd="@dimen/car_keyline_1"
+        android:scaleType="fitCenter"/>
+
+    <!-- Switch with divider. -->
+    <View
+        android:id="@+id/switch_divider"
+        android:layout_centerVertical="true"
+        android:layout_toStartOf="@id/switch_widget"
+        android:layout_marginEnd="@dimen/car_padding_4"
+        style="@style/CarListVerticalDivider"/>
+    <Switch
+        android:id="@+id/switch_widget"
+        android:layout_centerVertical="true"
+        android:layout_width="@dimen/car_primary_icon_size"
+        android:layout_height="@dimen/car_primary_icon_size"
+        android:layout_alignParentEnd="true"
+        android:layout_marginEnd="@dimen/car_keyline_1"
+        style="@android:style/Widget.Material.CompoundButton.Switch"/>
+
+    <!-- Up to 2 action buttons with dividers. -->
+    <View
+        android:id="@+id/action2_divider"
+        android:layout_centerVertical="true"
+        android:layout_toStartOf="@id/action2"
+        android:layout_marginEnd="@dimen/car_padding_4"
+        style="@style/CarListVerticalDivider"/>
+    <Button
+        android:id="@+id/action2"
+        android:layout_centerVertical="true"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_toStartOf="@id/action1_divider"
+        android:layout_marginEnd="@dimen/car_padding_4"
+        android:ellipsize="end"
+        android:maxLength="@integer/car_borderless_button_text_length_limit"
+        android:maxLines="1"
+        android:background="@color/car_card"
+        android:foreground="@drawable/car_card_ripple_background"
+        style="?android:attr/borderlessButtonStyle"/>
+    <View
+        android:id="@+id/action1_divider"
+        android:layout_centerVertical="true"
+        android:layout_toStartOf="@id/action1"
+        android:layout_marginEnd="@dimen/car_padding_4"
+        style="@style/CarListVerticalDivider"/>
+    <Button
+        android:id="@+id/action1"
+        android:layout_centerVertical="true"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_alignParentEnd="true"
+        android:layout_marginEnd="@dimen/car_keyline_1"
+        android:ellipsize="end"
+        android:maxLength="@integer/car_borderless_button_text_length_limit"
+        android:maxLines="1"
+        android:background="@color/car_card"
+        android:foreground="@drawable/car_card_ripple_background"
+        style="?android:attr/borderlessButtonStyle"/>
+</RelativeLayout>
diff --git a/android-car-lib/res/layout/car_paged_recycler_view.xml b/android-car-lib/res/layout/car_paged_recycler_view.xml
new file mode 100644
index 0000000..360d9a2
--- /dev/null
+++ b/android-car-lib/res/layout/car_paged_recycler_view.xml
@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2017 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.
+  -->
+<FrameLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent">
+
+    <androidx.recyclerview.widget.RecyclerView
+        android:id="@+id/recycler_view"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent" />
+
+    <!-- Putting this as the last child so that it can intercept any touch events on the
+         scroll buttons. -->
+    <androidx.car.widget.PagedScrollBarView
+        android:id="@+id/paged_scroll_view"
+        android:layout_width="@dimen/car_margin"
+        android:layout_height="match_parent"
+        android:paddingBottom="@dimen/car_padding_4"
+        android:paddingTop="@dimen/car_padding_4"
+        android:visibility="invisible" />
+</FrameLayout>
diff --git a/android-car-lib/res/layout/car_paged_scrollbar_buttons.xml b/android-car-lib/res/layout/car_paged_scrollbar_buttons.xml
new file mode 100644
index 0000000..b126b48
--- /dev/null
+++ b/android-car-lib/res/layout/car_paged_scrollbar_buttons.xml
@@ -0,0 +1,58 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2017 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:layout_gravity="center"
+    android:gravity="center"
+    android:orientation="vertical">
+
+    <ImageView
+        android:id="@+id/page_up"
+        android:layout_width="@dimen/car_scroll_bar_button_size"
+        android:layout_height="@dimen/car_scroll_bar_button_size"
+        android:background="@drawable/car_card_ripple_background"
+        android:focusable="false"
+        android:hapticFeedbackEnabled="false"
+        android:src="@drawable/ic_up" />
+
+    <FrameLayout
+        android:id="@+id/filler"
+        android:layout_width="match_parent"
+        android:layout_height="0dp"
+        android:layout_weight="1"
+        android:layout_marginBottom="@dimen/car_padding_2"
+        android:layout_marginTop="@dimen/car_padding_2" >
+
+        <View
+            android:id="@+id/scrollbar_thumb"
+            android:layout_width="@dimen/car_scroll_bar_thumb_width"
+            android:layout_height="0dp"
+            android:layout_gravity="center_horizontal"
+            android:background="@drawable/car_scrollbar_thumb" />
+    </FrameLayout>
+
+    <ImageView
+        android:id="@+id/page_down"
+        android:layout_width="@dimen/car_scroll_bar_button_size"
+        android:layout_height="@dimen/car_scroll_bar_button_size"
+        android:background="@drawable/car_card_ripple_background"
+        android:focusable="false"
+        android:hapticFeedbackEnabled="false"
+        android:src="@drawable/ic_down" />
+</LinearLayout>
diff --git a/android-car-lib/res/layout/car_toolbar.xml b/android-car-lib/res/layout/car_toolbar.xml
new file mode 100644
index 0000000..3926896
--- /dev/null
+++ b/android-car-lib/res/layout/car_toolbar.xml
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2017 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.
+-->
+<FrameLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="@dimen/car_app_bar_height">
+    <androidx.appcompat.widget.Toolbar
+        android:id="@+id/car_toolbar"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_gravity="center_vertical"
+        style="@style/Widget.Car.Toolbar" />
+</FrameLayout>
diff --git a/android-car-lib/res/layout/lock_out_message.xml b/android-car-lib/res/layout/lock_out_message.xml
new file mode 100644
index 0000000..220e1f3
--- /dev/null
+++ b/android-car-lib/res/layout/lock_out_message.xml
@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<RelativeLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/lock_out_message_container"
+    android:background="@drawable/speed_bump_scrim"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:layout_gravity="bottom"
+    android:visibility="gone">
+
+    <ImageView
+        android:id="@+id/lock_out_drawable"
+        android:layout_width="wrap_content"
+        android:layout_height="@dimen/speed_bump_lock_out_message_height"
+        android:layout_gravity="center"
+        android:layout_marginBottom="@dimen/speed_bump_lock_out_drawable_margin_bottom"
+        android:layout_alignParentBottom="true"
+        android:layout_centerHorizontal="true"
+        android:src="@drawable/lock_out_message_animation"/>
+
+    <!-- Align this TextView against the lock_out_drawable to ensure that the latter will wrap
+         this TextView. -->
+    <TextView
+        android:id="@+id/lock_out_text"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:textAppearance="@style/TextAppearance.Car.Body1"
+        android:layout_alignStart="@id/lock_out_drawable"
+        android:layout_alignEnd="@id/lock_out_drawable"
+        android:layout_alignTop="@id/lock_out_drawable"
+        android:layout_alignBottom="@id/lock_out_drawable"
+        android:gravity="center"
+        android:text="@string/speed_bump_lockout_message"/>
+</RelativeLayout>
diff --git a/android-car-lib/res/values-af/values-af.xml b/android-car-lib/res/values-af/values-af.xml
new file mode 100644
index 0000000..ed25d1d
--- /dev/null
+++ b/android-car-lib/res/values-af/values-af.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Konsentreer op die pad"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-af/values.xml b/android-car-lib/res/values-af/values.xml
new file mode 100644
index 0000000..7990a8e
--- /dev/null
+++ b/android-car-lib/res/values-af/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Vou knoppie in/uit"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Konsentreer op die pad"</string>
+</resources>
diff --git a/android-car-lib/res/values-am/values-am.xml b/android-car-lib/res/values-am/values-am.xml
new file mode 100644
index 0000000..529a04e
--- /dev/null
+++ b/android-car-lib/res/values-am/values-am.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"መንገዱ ላይ ያተኩሩ"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-am/values.xml b/android-car-lib/res/values-am/values.xml
new file mode 100644
index 0000000..8bd9ce9
--- /dev/null
+++ b/android-car-lib/res/values-am/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"አዝራርን ዘርጋ/ሰብስብ"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"መንገዱ ላይ ያተኩሩ"</string>
+</resources>
diff --git a/android-car-lib/res/values-ar/values-ar.xml b/android-car-lib/res/values-ar/values-ar.xml
new file mode 100644
index 0000000..3d64213
--- /dev/null
+++ b/android-car-lib/res/values-ar/values-ar.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"ركِّز في الطريق"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-ar/values.xml b/android-car-lib/res/values-ar/values.xml
new file mode 100644
index 0000000..a05692c
--- /dev/null
+++ b/android-car-lib/res/values-ar/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"زر التوسيع/التصغير"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"ركِّز في الطريق."</string>
+</resources>
diff --git a/android-car-lib/res/values-as/values.xml b/android-car-lib/res/values-as/values.xml
new file mode 100644
index 0000000..db2bb2f
--- /dev/null
+++ b/android-car-lib/res/values-as/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"সম্প্ৰসাৰণ/সংকোচন বুটাম"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"মনোযোগেৰে গাড়ী চলাওক"</string>
+</resources>
diff --git a/android-car-lib/res/values-az/values-az.xml b/android-car-lib/res/values-az/values-az.xml
new file mode 100644
index 0000000..b5b0f12
--- /dev/null
+++ b/android-car-lib/res/values-az/values-az.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Diqqətinizi yola yönəldin"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-az/values.xml b/android-car-lib/res/values-az/values.xml
new file mode 100644
index 0000000..822f446
--- /dev/null
+++ b/android-car-lib/res/values-az/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Düyməni genişləndirin/yığcamlaşdırın"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Diqqətinizi yola yönəldin"</string>
+</resources>
diff --git a/android-car-lib/res/values-b+sr+Latn/values-b+sr+Latn.xml b/android-car-lib/res/values-b+sr+Latn/values-b+sr+Latn.xml
new file mode 100644
index 0000000..97332eb
--- /dev/null
+++ b/android-car-lib/res/values-b+sr+Latn/values-b+sr+Latn.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Fokusirajte se na put"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-b+sr+Latn/values.xml b/android-car-lib/res/values-b+sr+Latn/values.xml
new file mode 100644
index 0000000..1da562a
--- /dev/null
+++ b/android-car-lib/res/values-b+sr+Latn/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Dugme Proširi/skupi"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Fokusirajte se na put"</string>
+</resources>
diff --git a/android-car-lib/res/values-be/values-be.xml b/android-car-lib/res/values-be/values-be.xml
new file mode 100644
index 0000000..cd54ef9
--- /dev/null
+++ b/android-car-lib/res/values-be/values-be.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Увага на дарогу"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-be/values.xml b/android-car-lib/res/values-be/values.xml
new file mode 100644
index 0000000..a33ac9b
--- /dev/null
+++ b/android-car-lib/res/values-be/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Кнопка \"Разгарнуць/згарнуць\""</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Увага на дарогу"</string>
+</resources>
diff --git a/android-car-lib/res/values-bg/values-bg.xml b/android-car-lib/res/values-bg/values-bg.xml
new file mode 100644
index 0000000..90f73ad
--- /dev/null
+++ b/android-car-lib/res/values-bg/values-bg.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Съсредоточете се върху пътя"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-bg/values.xml b/android-car-lib/res/values-bg/values.xml
new file mode 100644
index 0000000..18a283d
--- /dev/null
+++ b/android-car-lib/res/values-bg/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Бутон за разгъване/свиване"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Съсредоточете се върху пътя"</string>
+</resources>
diff --git a/android-car-lib/res/values-bn/values-bn.xml b/android-car-lib/res/values-bn/values-bn.xml
new file mode 100644
index 0000000..8a7d235
--- /dev/null
+++ b/android-car-lib/res/values-bn/values-bn.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"মনোযোগ দিয়ে গাড়ি চালান"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-bn/values.xml b/android-car-lib/res/values-bn/values.xml
new file mode 100644
index 0000000..ad4f5a0
--- /dev/null
+++ b/android-car-lib/res/values-bn/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"বোতামটি বড় করুন/আড়াল করুন"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"মনোযোগ দিয়ে গাড়ি চালান"</string>
+</resources>
diff --git a/android-car-lib/res/values-bs/values-bs.xml b/android-car-lib/res/values-bs/values-bs.xml
new file mode 100644
index 0000000..5cb1759
--- /dev/null
+++ b/android-car-lib/res/values-bs/values-bs.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Fokusirajte se na cestu"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-bs/values.xml b/android-car-lib/res/values-bs/values.xml
new file mode 100644
index 0000000..f9b4431
--- /dev/null
+++ b/android-car-lib/res/values-bs/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Dugme proširi/suzi"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Fokusirajte se na cestu"</string>
+</resources>
diff --git a/android-car-lib/res/values-ca/values-ca.xml b/android-car-lib/res/values-ca/values-ca.xml
new file mode 100644
index 0000000..2c1c31a
--- /dev/null
+++ b/android-car-lib/res/values-ca/values-ca.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Concentra\'t en la carretera"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-ca/values.xml b/android-car-lib/res/values-ca/values.xml
new file mode 100644
index 0000000..c9133a5
--- /dev/null
+++ b/android-car-lib/res/values-ca/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Botó per desplegar o replegar"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Concentra\'t en la carretera"</string>
+</resources>
diff --git a/android-car-lib/res/values-cs/values-cs.xml b/android-car-lib/res/values-cs/values-cs.xml
new file mode 100644
index 0000000..7bd877c
--- /dev/null
+++ b/android-car-lib/res/values-cs/values-cs.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Soustřeďte se na silnici"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-cs/values.xml b/android-car-lib/res/values-cs/values.xml
new file mode 100644
index 0000000..aad6789
--- /dev/null
+++ b/android-car-lib/res/values-cs/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Tlačítko rozbalení/sbalení"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Soustřeďte se na silnici"</string>
+</resources>
diff --git a/android-car-lib/res/values-da/values-da.xml b/android-car-lib/res/values-da/values-da.xml
new file mode 100644
index 0000000..54f7632
--- /dev/null
+++ b/android-car-lib/res/values-da/values-da.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Hold øjnene på vejen"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-da/values.xml b/android-car-lib/res/values-da/values.xml
new file mode 100644
index 0000000..fb82413
--- /dev/null
+++ b/android-car-lib/res/values-da/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Knappen Udvid/skjul"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Hold øjnene på vejen"</string>
+</resources>
diff --git a/android-car-lib/res/values-de/values-de.xml b/android-car-lib/res/values-de/values-de.xml
new file mode 100644
index 0000000..d0a35b5
--- /dev/null
+++ b/android-car-lib/res/values-de/values-de.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Achte auf den Verkehr"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-de/values.xml b/android-car-lib/res/values-de/values.xml
new file mode 100644
index 0000000..fb8e1c5
--- /dev/null
+++ b/android-car-lib/res/values-de/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Schaltfläche zum Maximieren/Minimieren"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Achte auf den Verkehr"</string>
+</resources>
diff --git a/android-car-lib/res/values-el/values-el.xml b/android-car-lib/res/values-el/values-el.xml
new file mode 100644
index 0000000..52758b1
--- /dev/null
+++ b/android-car-lib/res/values-el/values-el.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Επικεντρωθείτε στον δρόμο"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-el/values.xml b/android-car-lib/res/values-el/values.xml
new file mode 100644
index 0000000..e17e8f4
--- /dev/null
+++ b/android-car-lib/res/values-el/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Κουμπί ανάπτυξης/σύμπτυξης"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Επικεντρωθείτε στον δρόμο"</string>
+</resources>
diff --git a/android-car-lib/res/values-en-rAU/values-en-rAU.xml b/android-car-lib/res/values-en-rAU/values-en-rAU.xml
new file mode 100644
index 0000000..14ebe5f
--- /dev/null
+++ b/android-car-lib/res/values-en-rAU/values-en-rAU.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Focus on the road"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-en-rAU/values.xml b/android-car-lib/res/values-en-rAU/values.xml
new file mode 100644
index 0000000..b950788
--- /dev/null
+++ b/android-car-lib/res/values-en-rAU/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Expand/collapse button"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Focus on the road"</string>
+</resources>
diff --git a/android-car-lib/res/values-en-rCA/values-en-rCA.xml b/android-car-lib/res/values-en-rCA/values-en-rCA.xml
new file mode 100644
index 0000000..14ebe5f
--- /dev/null
+++ b/android-car-lib/res/values-en-rCA/values-en-rCA.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Focus on the road"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-en-rCA/values.xml b/android-car-lib/res/values-en-rCA/values.xml
new file mode 100644
index 0000000..b950788
--- /dev/null
+++ b/android-car-lib/res/values-en-rCA/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Expand/collapse button"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Focus on the road"</string>
+</resources>
diff --git a/android-car-lib/res/values-en-rGB/values-en-rGB.xml b/android-car-lib/res/values-en-rGB/values-en-rGB.xml
new file mode 100644
index 0000000..14ebe5f
--- /dev/null
+++ b/android-car-lib/res/values-en-rGB/values-en-rGB.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Focus on the road"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-en-rGB/values.xml b/android-car-lib/res/values-en-rGB/values.xml
new file mode 100644
index 0000000..b950788
--- /dev/null
+++ b/android-car-lib/res/values-en-rGB/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Expand/collapse button"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Focus on the road"</string>
+</resources>
diff --git a/android-car-lib/res/values-en-rIN/values-en-rIN.xml b/android-car-lib/res/values-en-rIN/values-en-rIN.xml
new file mode 100644
index 0000000..14ebe5f
--- /dev/null
+++ b/android-car-lib/res/values-en-rIN/values-en-rIN.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Focus on the road"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-en-rIN/values.xml b/android-car-lib/res/values-en-rIN/values.xml
new file mode 100644
index 0000000..b950788
--- /dev/null
+++ b/android-car-lib/res/values-en-rIN/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Expand/collapse button"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Focus on the road"</string>
+</resources>
diff --git a/android-car-lib/res/values-en-rXC/values-en-rXC.xml b/android-car-lib/res/values-en-rXC/values-en-rXC.xml
new file mode 100644
index 0000000..2644d8a
--- /dev/null
+++ b/android-car-lib/res/values-en-rXC/values-en-rXC.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‏‎‎‏‎‎‎‎‏‏‏‏‏‏‏‏‎‎‏‎‏‏‎‎‎‎‎‏‎‎‏‏‏‎‎‏‎‏‎‏‏‏‏‏‎‎‎‏‎‏‎‎‏‏‏‏‏‏‏‏‏‏‎‎‏‏‏‎‎‏‎‏‎‎‏‏‏‏‎Focus on the road‎‏‎‎‏‎"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-en-rXC/values.xml b/android-car-lib/res/values-en-rXC/values.xml
new file mode 100644
index 0000000..1d1d116
--- /dev/null
+++ b/android-car-lib/res/values-en-rXC/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‏‎‏‎‏‎‎‎‎‏‎‎‎‏‎‎‏‏‏‎‏‏‎‎‏‏‏‏‏‎‎‎‎‏‏‏‎‏‎‏‏‎‏‏‏‎‎‏‎‏‎‏‏‎‎‎‏‏‎‏‎‎‎‎‎Expand/collapse button‎‏‎‎‏‎"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‏‎‏‏‏‎‎‎‎‎‏‏‎‏‎‎‏‏‏‏‎‏‏‏‏‏‏‏‏‏‏‏‎‎‎‏‏‏‏‏‎‎‏‏‏‎‏‏‏‎‏‏‎‎‏‏‎‎‎‎‏‏‏‎‎Focus on the road‎‏‎‎‏‎"</string>
+</resources>
diff --git a/android-car-lib/res/values-es-rUS/values-es-rUS.xml b/android-car-lib/res/values-es-rUS/values-es-rUS.xml
new file mode 100644
index 0000000..e5ecf44
--- /dev/null
+++ b/android-car-lib/res/values-es-rUS/values-es-rUS.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Concéntrate en el camino"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-es-rUS/values.xml b/android-car-lib/res/values-es-rUS/values.xml
new file mode 100644
index 0000000..0a3e9a8
--- /dev/null
+++ b/android-car-lib/res/values-es-rUS/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Botón Expandir/contraer"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Concéntrate en el camino"</string>
+</resources>
diff --git a/android-car-lib/res/values-es/values-es.xml b/android-car-lib/res/values-es/values-es.xml
new file mode 100644
index 0000000..2af260c
--- /dev/null
+++ b/android-car-lib/res/values-es/values-es.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Céntrate en la carretera"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-es/values.xml b/android-car-lib/res/values-es/values.xml
new file mode 100644
index 0000000..a175812
--- /dev/null
+++ b/android-car-lib/res/values-es/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Botón para mostrar u ocultar"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Céntrate en la carretera"</string>
+</resources>
diff --git a/android-car-lib/res/values-et/values-et.xml b/android-car-lib/res/values-et/values-et.xml
new file mode 100644
index 0000000..30fce07
--- /dev/null
+++ b/android-car-lib/res/values-et/values-et.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Keskenduge teele"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-et/values.xml b/android-car-lib/res/values-et/values.xml
new file mode 100644
index 0000000..18e9283
--- /dev/null
+++ b/android-car-lib/res/values-et/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Nupp Laienda/Ahenda"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Keskenduge teele"</string>
+</resources>
diff --git a/android-car-lib/res/values-eu/values-eu.xml b/android-car-lib/res/values-eu/values-eu.xml
new file mode 100644
index 0000000..65513d4
--- /dev/null
+++ b/android-car-lib/res/values-eu/values-eu.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Jarri arreta errepidean"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-eu/values.xml b/android-car-lib/res/values-eu/values.xml
new file mode 100644
index 0000000..4e2c741
--- /dev/null
+++ b/android-car-lib/res/values-eu/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Zabaltzeko/Tolesteko botoia"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Jarri arreta errepidean"</string>
+</resources>
diff --git a/android-car-lib/res/values-fa/values-fa.xml b/android-car-lib/res/values-fa/values-fa.xml
new file mode 100644
index 0000000..f683363
--- /dev/null
+++ b/android-car-lib/res/values-fa/values-fa.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"روی جاده تمرکز داشته باشید"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-fa/values.xml b/android-car-lib/res/values-fa/values.xml
new file mode 100644
index 0000000..319b857
--- /dev/null
+++ b/android-car-lib/res/values-fa/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"دکمه بزرگ کردن/کوچک کردن"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"روی جاده تمرکز داشته باشید"</string>
+</resources>
diff --git a/android-car-lib/res/values-fi/values-fi.xml b/android-car-lib/res/values-fi/values-fi.xml
new file mode 100644
index 0000000..b7223be
--- /dev/null
+++ b/android-car-lib/res/values-fi/values-fi.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Pidä katse tiessä"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-fi/values.xml b/android-car-lib/res/values-fi/values.xml
new file mode 100644
index 0000000..7e917d2
--- /dev/null
+++ b/android-car-lib/res/values-fi/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Laajennus- ja tiivistyspainike"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Pidä katse tiessä"</string>
+</resources>
diff --git a/android-car-lib/res/values-fr-rCA/values-fr-rCA.xml b/android-car-lib/res/values-fr-rCA/values-fr-rCA.xml
new file mode 100644
index 0000000..79e44c5
--- /dev/null
+++ b/android-car-lib/res/values-fr-rCA/values-fr-rCA.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Concentrez-vous sur la route"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-fr-rCA/values.xml b/android-car-lib/res/values-fr-rCA/values.xml
new file mode 100644
index 0000000..e44d8cb
--- /dev/null
+++ b/android-car-lib/res/values-fr-rCA/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Bouton Développer/Réduire"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Concentrez-vous sur la route"</string>
+</resources>
diff --git a/android-car-lib/res/values-fr/values-fr.xml b/android-car-lib/res/values-fr/values-fr.xml
new file mode 100644
index 0000000..79e44c5
--- /dev/null
+++ b/android-car-lib/res/values-fr/values-fr.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Concentrez-vous sur la route"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-fr/values.xml b/android-car-lib/res/values-fr/values.xml
new file mode 100644
index 0000000..e44d8cb
--- /dev/null
+++ b/android-car-lib/res/values-fr/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Bouton Développer/Réduire"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Concentrez-vous sur la route"</string>
+</resources>
diff --git a/android-car-lib/res/values-gl/values-gl.xml b/android-car-lib/res/values-gl/values-gl.xml
new file mode 100644
index 0000000..d024b93
--- /dev/null
+++ b/android-car-lib/res/values-gl/values-gl.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Céntrate na estrada"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-gl/values.xml b/android-car-lib/res/values-gl/values.xml
new file mode 100644
index 0000000..9b09422
--- /dev/null
+++ b/android-car-lib/res/values-gl/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Botón despregar/contraer"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Céntrate na estrada"</string>
+</resources>
diff --git a/android-car-lib/res/values-gu/values-gu.xml b/android-car-lib/res/values-gu/values-gu.xml
new file mode 100644
index 0000000..6b0f8d5
--- /dev/null
+++ b/android-car-lib/res/values-gu/values-gu.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"રસ્તા પર ફોકસ કરો"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-gu/values.xml b/android-car-lib/res/values-gu/values.xml
new file mode 100644
index 0000000..8735563
--- /dev/null
+++ b/android-car-lib/res/values-gu/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"વિસ્તાર કરો/સંકુચિત કરો બટન"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"રસ્તા પર ફોકસ કરો"</string>
+</resources>
diff --git a/android-car-lib/res/values-h1752dp-v13/values-h1752dp-v13.xml b/android-car-lib/res/values-h1752dp-v13/values-h1752dp-v13.xml
new file mode 100644
index 0000000..9eb87ed
--- /dev/null
+++ b/android-car-lib/res/values-h1752dp-v13/values-h1752dp-v13.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <dimen name="car_action1_size">32sp</dimen>
+    <dimen name="car_app_bar_height">112dp</dimen>
+    <dimen name="car_avatar_size">96dp</dimen>
+    <dimen name="car_body1_size">40sp</dimen>
+    <dimen name="car_body2_size">32sp</dimen>
+    <dimen name="car_card_action_bar_height">96dp</dimen>
+    <dimen name="car_card_header_height">96dp</dimen>
+    <dimen name="car_headline1_size">56sp</dimen>
+    <dimen name="car_headline2_size">50sp</dimen>
+    <dimen name="car_label1_size">32sp</dimen>
+    <dimen name="car_primary_icon_size">56dp</dimen>
+    <dimen name="car_secondary_icon_size">36dp</dimen>
+    <dimen name="car_single_line_list_item_height">128dp</dimen>
+    <dimen name="car_slide_up_menu_initial_height">128dp</dimen>
+    <dimen name="car_sub_header_height">96dp</dimen>
+    <dimen name="car_title2_size">40sp</dimen>
+    <dimen name="car_touch_target_size">96dp</dimen>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-h668dp-v13/values-h668dp-v13.xml b/android-car-lib/res/values-h668dp-v13/values-h668dp-v13.xml
new file mode 100644
index 0000000..127e094
--- /dev/null
+++ b/android-car-lib/res/values-h668dp-v13/values-h668dp-v13.xml
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <dimen name="car_app_bar_height">96dp</dimen>
+    <dimen name="car_drawer_list_item_end_icon_size">56dp</dimen>
+    <dimen name="car_drawer_list_item_icon_size">108dp</dimen>
+    <dimen name="car_drawer_list_item_small_icon_size">56dp</dimen>
+    <dimen name="car_headline2_size">36sp</dimen>
+    <dimen name="car_padding_2">16dp</dimen>
+    <dimen name="car_padding_3">28dp</dimen>
+    <dimen name="car_padding_4">32dp</dimen>
+    <dimen name="car_padding_5">64dp</dimen>
+    <dimen name="car_padding_6">96dp</dimen>
+    <dimen name="car_scroll_bar_button_size">76dp</dimen>
+    <dimen name="car_single_line_list_item_height">116dp</dimen>
+    <dimen name="car_slide_up_menu_initial_height">116dp</dimen>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-hi/values-hi.xml b/android-car-lib/res/values-hi/values-hi.xml
new file mode 100644
index 0000000..5430f04
--- /dev/null
+++ b/android-car-lib/res/values-hi/values-hi.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"सड़क पर ध्यान दें"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-hi/values.xml b/android-car-lib/res/values-hi/values.xml
new file mode 100644
index 0000000..d2cb5f8
--- /dev/null
+++ b/android-car-lib/res/values-hi/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"बड़ा/छोटा करने वाला बटन"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"सड़क पर ध्यान दें"</string>
+</resources>
diff --git a/android-car-lib/res/values-hr/values-hr.xml b/android-car-lib/res/values-hr/values-hr.xml
new file mode 100644
index 0000000..dc7be15
--- /dev/null
+++ b/android-car-lib/res/values-hr/values-hr.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Usredotočite se na cestu"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-hr/values.xml b/android-car-lib/res/values-hr/values.xml
new file mode 100644
index 0000000..d279d04
--- /dev/null
+++ b/android-car-lib/res/values-hr/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Gumb za proširivanje/sažimanje"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Usredotočite se na cestu"</string>
+</resources>
diff --git a/android-car-lib/res/values-hu/values-hu.xml b/android-car-lib/res/values-hu/values-hu.xml
new file mode 100644
index 0000000..1e7ff2c
--- /dev/null
+++ b/android-car-lib/res/values-hu/values-hu.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Figyeljen az útra"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-hu/values.xml b/android-car-lib/res/values-hu/values.xml
new file mode 100644
index 0000000..e009ab8
--- /dev/null
+++ b/android-car-lib/res/values-hu/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Gomb kibontása/összecsukása"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Figyeljen az útra"</string>
+</resources>
diff --git a/android-car-lib/res/values-hy/values-hy.xml b/android-car-lib/res/values-hy/values-hy.xml
new file mode 100644
index 0000000..54ba33e
--- /dev/null
+++ b/android-car-lib/res/values-hy/values-hy.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Հետևեք ճանապարհին"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-hy/values.xml b/android-car-lib/res/values-hy/values.xml
new file mode 100644
index 0000000..05a225d
--- /dev/null
+++ b/android-car-lib/res/values-hy/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"«Ընդարձակել/ծալել» կոճակ"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Հետևեք ճանապարհին"</string>
+</resources>
diff --git a/android-car-lib/res/values-in/values-in.xml b/android-car-lib/res/values-in/values-in.xml
new file mode 100644
index 0000000..25b10ed
--- /dev/null
+++ b/android-car-lib/res/values-in/values-in.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Konsentrasi saat mengemudi"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-in/values.xml b/android-car-lib/res/values-in/values.xml
new file mode 100644
index 0000000..33e98c8
--- /dev/null
+++ b/android-car-lib/res/values-in/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Tombol luaskan/ciutkan"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Konsentrasi saat mengemudi"</string>
+</resources>
diff --git a/android-car-lib/res/values-is/values-is.xml b/android-car-lib/res/values-is/values-is.xml
new file mode 100644
index 0000000..c48d73b
--- /dev/null
+++ b/android-car-lib/res/values-is/values-is.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Einbeittu þér að akstrinum"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-is/values.xml b/android-car-lib/res/values-is/values.xml
new file mode 100644
index 0000000..8db74e8
--- /dev/null
+++ b/android-car-lib/res/values-is/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Hnappur til að stækka/minnka"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Einbeittu þér að akstrinum"</string>
+</resources>
diff --git a/android-car-lib/res/values-it/values-it.xml b/android-car-lib/res/values-it/values-it.xml
new file mode 100644
index 0000000..64780ad
--- /dev/null
+++ b/android-car-lib/res/values-it/values-it.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Concentrati sulla strada"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-it/values.xml b/android-car-lib/res/values-it/values.xml
new file mode 100644
index 0000000..42e9fb6
--- /dev/null
+++ b/android-car-lib/res/values-it/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Pulsante Espandi/Comprimi"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Concentrati sulla strada"</string>
+</resources>
diff --git a/android-car-lib/res/values-iw/values-iw.xml b/android-car-lib/res/values-iw/values-iw.xml
new file mode 100644
index 0000000..3af92b7
--- /dev/null
+++ b/android-car-lib/res/values-iw/values-iw.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"עליך להתמקד בכביש"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-iw/values.xml b/android-car-lib/res/values-iw/values.xml
new file mode 100644
index 0000000..9a5d0d9
--- /dev/null
+++ b/android-car-lib/res/values-iw/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"לחצן הרחבה וכיווץ"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"עליך להתמקד בכביש"</string>
+</resources>
diff --git a/android-car-lib/res/values-ja/values-ja.xml b/android-car-lib/res/values-ja/values-ja.xml
new file mode 100644
index 0000000..598f61f
--- /dev/null
+++ b/android-car-lib/res/values-ja/values-ja.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"運転に集中してください"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-ja/values.xml b/android-car-lib/res/values-ja/values.xml
new file mode 100644
index 0000000..004bc89
--- /dev/null
+++ b/android-car-lib/res/values-ja/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"展開 / 折りたたみボタン"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"運転に集中してください"</string>
+</resources>
diff --git a/android-car-lib/res/values-ka/values-ka.xml b/android-car-lib/res/values-ka/values-ka.xml
new file mode 100644
index 0000000..0e5a161
--- /dev/null
+++ b/android-car-lib/res/values-ka/values-ka.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"კონცენტრირდით გზაზე"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-ka/values.xml b/android-car-lib/res/values-ka/values.xml
new file mode 100644
index 0000000..fa26c0c
--- /dev/null
+++ b/android-car-lib/res/values-ka/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"ღილაკის გაშლა/ჩაკეცვა"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"კონცენტრირდით გზაზე"</string>
+</resources>
diff --git a/android-car-lib/res/values-kk/values-kk.xml b/android-car-lib/res/values-kk/values-kk.xml
new file mode 100644
index 0000000..b70f1db
--- /dev/null
+++ b/android-car-lib/res/values-kk/values-kk.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Жолға назар аударыңыз"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-kk/values.xml b/android-car-lib/res/values-kk/values.xml
new file mode 100644
index 0000000..a90524b
--- /dev/null
+++ b/android-car-lib/res/values-kk/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"\"Жаю/Жию\" түймесі"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Жолға назар аударыңыз"</string>
+</resources>
diff --git a/android-car-lib/res/values-km/values-km.xml b/android-car-lib/res/values-km/values-km.xml
new file mode 100644
index 0000000..b550049
--- /dev/null
+++ b/android-car-lib/res/values-km/values-km.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"ផ្តោតលើ​ការបើកបរ"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-km/values.xml b/android-car-lib/res/values-km/values.xml
new file mode 100644
index 0000000..8fc71c6
--- /dev/null
+++ b/android-car-lib/res/values-km/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"ប៊ូតុង​ពង្រីក/បង្រួម"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"ផ្តោតលើ​ការបើកបរ"</string>
+</resources>
diff --git a/android-car-lib/res/values-kn/values-kn.xml b/android-car-lib/res/values-kn/values-kn.xml
new file mode 100644
index 0000000..cf77bf0
--- /dev/null
+++ b/android-car-lib/res/values-kn/values-kn.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"ರಸ್ತೆಯ ಮೇಲೆ ಗಮನಹರಿಸಿ"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-kn/values.xml b/android-car-lib/res/values-kn/values.xml
new file mode 100644
index 0000000..dea965f
--- /dev/null
+++ b/android-car-lib/res/values-kn/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"ವಿಸ್ತರಿಸಿ/ಕುಗ್ಗಿಸಿ ಬಟನ್"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"ರಸ್ತೆಯ ಮೇಲೆ ಗಮನಹರಿಸಿ"</string>
+</resources>
diff --git a/android-car-lib/res/values-ko/values-ko.xml b/android-car-lib/res/values-ko/values-ko.xml
new file mode 100644
index 0000000..5564a12
--- /dev/null
+++ b/android-car-lib/res/values-ko/values-ko.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"도로 상황에 집중하세요."</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-ko/values.xml b/android-car-lib/res/values-ko/values.xml
new file mode 100644
index 0000000..62f39d1
--- /dev/null
+++ b/android-car-lib/res/values-ko/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"펼치기/접기 버튼"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"도로 상황에 집중하세요."</string>
+</resources>
diff --git a/android-car-lib/res/values-ky/values-ky.xml b/android-car-lib/res/values-ky/values-ky.xml
new file mode 100644
index 0000000..eb5b9dc
--- /dev/null
+++ b/android-car-lib/res/values-ky/values-ky.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Жолго көңүл буруңуз"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-ky/values.xml b/android-car-lib/res/values-ky/values.xml
new file mode 100644
index 0000000..5a48f45
--- /dev/null
+++ b/android-car-lib/res/values-ky/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Жайып көрсөтүү/жыйыштыруу баскычы"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Жолго көңүл буруңуз"</string>
+</resources>
diff --git a/android-car-lib/res/values-lo/values-lo.xml b/android-car-lib/res/values-lo/values-lo.xml
new file mode 100644
index 0000000..332f827
--- /dev/null
+++ b/android-car-lib/res/values-lo/values-lo.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"ຕັ້ງໃຈຂັບລົດ"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-lo/values.xml b/android-car-lib/res/values-lo/values.xml
new file mode 100644
index 0000000..96a8c09
--- /dev/null
+++ b/android-car-lib/res/values-lo/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"ປຸ່ມຂະຫຍາຍ/ຫຍໍ້ລົງ"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"ຕັ້ງໃຈຂັບລົດ"</string>
+</resources>
diff --git a/android-car-lib/res/values-lt/values-lt.xml b/android-car-lib/res/values-lt/values-lt.xml
new file mode 100644
index 0000000..cad45a9
--- /dev/null
+++ b/android-car-lib/res/values-lt/values-lt.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Sutelkite dėmesį į kelią"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-lt/values.xml b/android-car-lib/res/values-lt/values.xml
new file mode 100644
index 0000000..d77e8b0
--- /dev/null
+++ b/android-car-lib/res/values-lt/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Mygtukas „Išskleisti / sutraukti“"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Sutelkite dėmesį į kelią"</string>
+</resources>
diff --git a/android-car-lib/res/values-lv/values-lv.xml b/android-car-lib/res/values-lv/values-lv.xml
new file mode 100644
index 0000000..fa8b02b
--- /dev/null
+++ b/android-car-lib/res/values-lv/values-lv.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Pievērsieties autovadīšanai"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-lv/values.xml b/android-car-lib/res/values-lv/values.xml
new file mode 100644
index 0000000..a29444b
--- /dev/null
+++ b/android-car-lib/res/values-lv/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Izvēršanas/sakļaušanas poga"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Pievērsieties ceļam"</string>
+</resources>
diff --git a/android-car-lib/res/values-mk/values-mk.xml b/android-car-lib/res/values-mk/values-mk.xml
new file mode 100644
index 0000000..a1fec3e
--- /dev/null
+++ b/android-car-lib/res/values-mk/values-mk.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Фокусирајте се на патот"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-mk/values.xml b/android-car-lib/res/values-mk/values.xml
new file mode 100644
index 0000000..ae4ceb5
--- /dev/null
+++ b/android-car-lib/res/values-mk/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Копче за проширување/собирање"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Фокусирајте се на патот"</string>
+</resources>
diff --git a/android-car-lib/res/values-ml/values-ml.xml b/android-car-lib/res/values-ml/values-ml.xml
new file mode 100644
index 0000000..0301e61
--- /dev/null
+++ b/android-car-lib/res/values-ml/values-ml.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"റോഡിൽ ശ്രദ്ധിക്കുക"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-ml/values.xml b/android-car-lib/res/values-ml/values.xml
new file mode 100644
index 0000000..5399293
--- /dev/null
+++ b/android-car-lib/res/values-ml/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"വികസിപ്പിക്കുക/ചുരുക്കുക ബട്ടൺ"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"റോഡിൽ ശ്രദ്ധിക്കുക"</string>
+</resources>
diff --git a/android-car-lib/res/values-mn/values-mn.xml b/android-car-lib/res/values-mn/values-mn.xml
new file mode 100644
index 0000000..3d2a53f
--- /dev/null
+++ b/android-car-lib/res/values-mn/values-mn.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Зам дээр төвлөрөх"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-mn/values.xml b/android-car-lib/res/values-mn/values.xml
new file mode 100644
index 0000000..abe78f1
--- /dev/null
+++ b/android-car-lib/res/values-mn/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Дэлгэх/буулгах товчлуур"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Зам дээр анхаарлаа төвлөрүүлэх"</string>
+</resources>
diff --git a/android-car-lib/res/values-mr/values-mr.xml b/android-car-lib/res/values-mr/values-mr.xml
new file mode 100644
index 0000000..9f9dfa7
--- /dev/null
+++ b/android-car-lib/res/values-mr/values-mr.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"रस्त्यावर फोकस करा"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-mr/values.xml b/android-car-lib/res/values-mr/values.xml
new file mode 100644
index 0000000..77e890f
--- /dev/null
+++ b/android-car-lib/res/values-mr/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"बटण विस्‍तृत करा/कोलॅप्‍स करा"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"रस्त्यावर फोकस करा"</string>
+</resources>
diff --git a/android-car-lib/res/values-ms/values-ms.xml b/android-car-lib/res/values-ms/values-ms.xml
new file mode 100644
index 0000000..f5e24b5
--- /dev/null
+++ b/android-car-lib/res/values-ms/values-ms.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Beri tumpuan pada jalan raya"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-ms/values.xml b/android-car-lib/res/values-ms/values.xml
new file mode 100644
index 0000000..d04485b
--- /dev/null
+++ b/android-car-lib/res/values-ms/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Butang kembangkan/runtuhkan"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Beri tumpuan pada jalan raya"</string>
+</resources>
diff --git a/android-car-lib/res/values-my/values-my.xml b/android-car-lib/res/values-my/values-my.xml
new file mode 100644
index 0000000..617468e
--- /dev/null
+++ b/android-car-lib/res/values-my/values-my.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"လမ်းကို အာရုံစိုက်ရန်"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-my/values.xml b/android-car-lib/res/values-my/values.xml
new file mode 100644
index 0000000..be8c9fc
--- /dev/null
+++ b/android-car-lib/res/values-my/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"ချဲ့ရန်/လျှော့ပြရန် ခလုတ်"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"လမ်းပေါ်တွင် အာရုံစိုက်ပါ"</string>
+</resources>
diff --git a/android-car-lib/res/values-nb/values-nb.xml b/android-car-lib/res/values-nb/values-nb.xml
new file mode 100644
index 0000000..7f50f78
--- /dev/null
+++ b/android-car-lib/res/values-nb/values-nb.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Fokuser på veien"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-nb/values.xml b/android-car-lib/res/values-nb/values.xml
new file mode 100644
index 0000000..5575a1a
--- /dev/null
+++ b/android-car-lib/res/values-nb/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Vis/skjul-knapp"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Fokuser på veien"</string>
+</resources>
diff --git a/android-car-lib/res/values-ne/values-ne.xml b/android-car-lib/res/values-ne/values-ne.xml
new file mode 100644
index 0000000..91acb81
--- /dev/null
+++ b/android-car-lib/res/values-ne/values-ne.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"सडकमा ध्यान केन्द्रित गर्नु…"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-ne/values.xml b/android-car-lib/res/values-ne/values.xml
new file mode 100644
index 0000000..b366be2
--- /dev/null
+++ b/android-car-lib/res/values-ne/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"विस्तृत/संक्षिप्त गर्ने बटन"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"सडकमा ध्यान केन्द्रित गर्नुहोस्"</string>
+</resources>
diff --git a/android-car-lib/res/values-night-v8/values-night-v8.xml b/android-car-lib/res/values-night-v8/values-night-v8.xml
new file mode 100644
index 0000000..e9a243a
--- /dev/null
+++ b/android-car-lib/res/values-night-v8/values-night-v8.xml
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="car_accent">@color/car_accent_light</color>
+    <color name="car_action1">@color/car_action1_light</color>
+    <color name="car_body1">@color/car_body1_light</color>
+    <color name="car_body2">@color/car_body2_light</color>
+    <color name="car_body3">@color/car_body3_light</color>
+    <color name="car_body4">@color/car_body4_light</color>
+    <color name="car_card">@color/car_card_dark</color>
+    <color name="car_card_inverse">@color/car_card_light</color>
+    <color name="car_card_ripple_background">@color/car_card_ripple_background_light</color>
+    <color name="car_card_ripple_background_inverse">@color/car_card_ripple_background_dark</color>
+    <color name="car_headline1">@color/car_headline1_light</color>
+    <color name="car_headline2">@color/car_headline2_light</color>
+    <color name="car_headline3">@color/car_headline3_light</color>
+    <color name="car_headline4">@color/car_headline4_light</color>
+    <color name="car_label1">@color/car_label1_light</color>
+    <color name="car_list_divider">@color/car_list_divider_light</color>
+    <color name="car_list_divider_inverse">@color/car_list_divider_dark</color>
+    <color name="car_scrollbar_thumb">@color/car_scrollbar_thumb_light</color>
+    <color name="car_scrollbar_thumb_inverse">@color/car_scrollbar_thumb_dark</color>
+    <color name="car_tint">@color/car_tint_light</color>
+    <color name="car_tint_inverse">@color/car_tint_dark</color>
+    <color name="car_title">@color/car_title_light</color>
+    <color name="car_title2">@color/car_title2_light</color>
+    <color name="speed_bump_background">#FF4C4C4C</color>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-nl/values-nl.xml b/android-car-lib/res/values-nl/values-nl.xml
new file mode 100644
index 0000000..756b53d
--- /dev/null
+++ b/android-car-lib/res/values-nl/values-nl.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Houd je aandacht op de weg"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-nl/values.xml b/android-car-lib/res/values-nl/values.xml
new file mode 100644
index 0000000..de8f173
--- /dev/null
+++ b/android-car-lib/res/values-nl/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Knop voor uitvouwen/samenvouwen"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Houd je aandacht op de weg"</string>
+</resources>
diff --git a/android-car-lib/res/values-or/values.xml b/android-car-lib/res/values-or/values.xml
new file mode 100644
index 0000000..1836305
--- /dev/null
+++ b/android-car-lib/res/values-or/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"ବିସ୍ତାର/ସଂକୋଚନ ବଟନ୍"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"ରାସ୍ତା ଉପରେ ଧ୍ୟାନରଖନ୍ତୁ"</string>
+</resources>
diff --git a/android-car-lib/res/values-pa/values-pa.xml b/android-car-lib/res/values-pa/values-pa.xml
new file mode 100644
index 0000000..8aec306
--- /dev/null
+++ b/android-car-lib/res/values-pa/values-pa.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"ਸੜਕ \'ਤੇ ਧਿਆਨ ਦਿਓ"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-pa/values.xml b/android-car-lib/res/values-pa/values.xml
new file mode 100644
index 0000000..c4369d3
--- /dev/null
+++ b/android-car-lib/res/values-pa/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"ਵਿਸਤਾਰ ਕਰੋ ਜਾਂ ਸਮੇਟੋ ਬਟਨ"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"ਸੜਕ \'ਤੇ ਧਿਆਨ ਦਿਓ"</string>
+</resources>
diff --git a/android-car-lib/res/values-pl/values-pl.xml b/android-car-lib/res/values-pl/values-pl.xml
new file mode 100644
index 0000000..32a3af6
--- /dev/null
+++ b/android-car-lib/res/values-pl/values-pl.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Skup się na drodze"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-pl/values.xml b/android-car-lib/res/values-pl/values.xml
new file mode 100644
index 0000000..0373349
--- /dev/null
+++ b/android-car-lib/res/values-pl/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Przycisk zwijania/rozwijania"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Skup się na drodze"</string>
+</resources>
diff --git a/android-car-lib/res/values-pt-rBR/values-pt-rBR.xml b/android-car-lib/res/values-pt-rBR/values-pt-rBR.xml
new file mode 100644
index 0000000..01c5f31
--- /dev/null
+++ b/android-car-lib/res/values-pt-rBR/values-pt-rBR.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Foco na estrada"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-pt-rPT/values-pt-rPT.xml b/android-car-lib/res/values-pt-rPT/values-pt-rPT.xml
new file mode 100644
index 0000000..9cc59bc
--- /dev/null
+++ b/android-car-lib/res/values-pt-rPT/values-pt-rPT.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Concentre-se na estrada."</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-pt-rPT/values.xml b/android-car-lib/res/values-pt-rPT/values.xml
new file mode 100644
index 0000000..85c248a
--- /dev/null
+++ b/android-car-lib/res/values-pt-rPT/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Botão Expandir/reduzir"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Concentre-se na estrada"</string>
+</resources>
diff --git a/android-car-lib/res/values-pt/values-pt.xml b/android-car-lib/res/values-pt/values-pt.xml
new file mode 100644
index 0000000..01c5f31
--- /dev/null
+++ b/android-car-lib/res/values-pt/values-pt.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Foco na estrada"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-pt/values.xml b/android-car-lib/res/values-pt/values.xml
new file mode 100644
index 0000000..8d7071d
--- /dev/null
+++ b/android-car-lib/res/values-pt/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Botão \"Expandir/Recolher\""</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Foco na estrada"</string>
+</resources>
diff --git a/android-car-lib/res/values-ro/values-ro.xml b/android-car-lib/res/values-ro/values-ro.xml
new file mode 100644
index 0000000..72b3ef7
--- /dev/null
+++ b/android-car-lib/res/values-ro/values-ro.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Concentrați-vă asupra drumului"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-ro/values.xml b/android-car-lib/res/values-ro/values.xml
new file mode 100644
index 0000000..4a40973
--- /dev/null
+++ b/android-car-lib/res/values-ro/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Butonul de extindere/restrângere"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Concentrați-vă asupra drumului"</string>
+</resources>
diff --git a/android-car-lib/res/values-ru/values-ru.xml b/android-car-lib/res/values-ru/values-ru.xml
new file mode 100644
index 0000000..96f1b8f
--- /dev/null
+++ b/android-car-lib/res/values-ru/values-ru.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Следите за дорогой"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-ru/values.xml b/android-car-lib/res/values-ru/values.xml
new file mode 100644
index 0000000..82def43
--- /dev/null
+++ b/android-car-lib/res/values-ru/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Кнопка \"Развернуть/свернуть\""</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Следите за дорогой"</string>
+</resources>
diff --git a/android-car-lib/res/values-si/values-si.xml b/android-car-lib/res/values-si/values-si.xml
new file mode 100644
index 0000000..53aeba6
--- /dev/null
+++ b/android-car-lib/res/values-si/values-si.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"මාර්ගයට අවධානය යොමු කරන්න"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-si/values.xml b/android-car-lib/res/values-si/values.xml
new file mode 100644
index 0000000..d841b61
--- /dev/null
+++ b/android-car-lib/res/values-si/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"දිග හැරීමේ/හැකිළීමේ බොත්තම"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"මාර්ගයට අවධානය යොමු කරන්න"</string>
+</resources>
diff --git a/android-car-lib/res/values-sk/values-sk.xml b/android-car-lib/res/values-sk/values-sk.xml
new file mode 100644
index 0000000..20634da
--- /dev/null
+++ b/android-car-lib/res/values-sk/values-sk.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Sústreďte sa na cestu"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-sk/values.xml b/android-car-lib/res/values-sk/values.xml
new file mode 100644
index 0000000..cd78105
--- /dev/null
+++ b/android-car-lib/res/values-sk/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Tlačidlo rozbalenia/zbalenia"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Sústreďte sa na cestu"</string>
+</resources>
diff --git a/android-car-lib/res/values-sl/values-sl.xml b/android-car-lib/res/values-sl/values-sl.xml
new file mode 100644
index 0000000..6a8dd70
--- /dev/null
+++ b/android-car-lib/res/values-sl/values-sl.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Glejte na cesto"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-sl/values.xml b/android-car-lib/res/values-sl/values.xml
new file mode 100644
index 0000000..db5e068
--- /dev/null
+++ b/android-car-lib/res/values-sl/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Gumb za razširitev/strnitev"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Glejte na cesto"</string>
+</resources>
diff --git a/android-car-lib/res/values-sq/values-sq.xml b/android-car-lib/res/values-sq/values-sq.xml
new file mode 100644
index 0000000..2079f47
--- /dev/null
+++ b/android-car-lib/res/values-sq/values-sq.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Përqendrohu te rruga"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-sq/values.xml b/android-car-lib/res/values-sq/values.xml
new file mode 100644
index 0000000..e72a586
--- /dev/null
+++ b/android-car-lib/res/values-sq/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Butoni i zgjerimit/palosjes"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Përqendrohu te rruga"</string>
+</resources>
diff --git a/android-car-lib/res/values-sr/values-sr.xml b/android-car-lib/res/values-sr/values-sr.xml
new file mode 100644
index 0000000..428dcc6
--- /dev/null
+++ b/android-car-lib/res/values-sr/values-sr.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Фокусирајте се на пут"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-sr/values.xml b/android-car-lib/res/values-sr/values.xml
new file mode 100644
index 0000000..2c6b1ea
--- /dev/null
+++ b/android-car-lib/res/values-sr/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Дугме Прошири/скупи"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Фокусирајте се на пут"</string>
+</resources>
diff --git a/android-car-lib/res/values-sv/values-sv.xml b/android-car-lib/res/values-sv/values-sv.xml
new file mode 100644
index 0000000..b63afe6
--- /dev/null
+++ b/android-car-lib/res/values-sv/values-sv.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Fokusera på körningen"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-sv/values.xml b/android-car-lib/res/values-sv/values.xml
new file mode 100644
index 0000000..d7a7ca4
--- /dev/null
+++ b/android-car-lib/res/values-sv/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Knappen Utöka/komprimera"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Fokusera på körningen"</string>
+</resources>
diff --git a/android-car-lib/res/values-sw/values-sw.xml b/android-car-lib/res/values-sw/values-sw.xml
new file mode 100644
index 0000000..4b3d68a
--- /dev/null
+++ b/android-car-lib/res/values-sw/values-sw.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Tia makini barabarani"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-sw/values.xml b/android-car-lib/res/values-sw/values.xml
new file mode 100644
index 0000000..dfb951c
--- /dev/null
+++ b/android-car-lib/res/values-sw/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Kitufe cha kupanua/kukunja"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Makinika barabarani"</string>
+</resources>
diff --git a/android-car-lib/res/values-ta/values-ta.xml b/android-car-lib/res/values-ta/values-ta.xml
new file mode 100644
index 0000000..0718f29
--- /dev/null
+++ b/android-car-lib/res/values-ta/values-ta.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"வாகனம் ஓட்டும்போது கவனம் தேவை"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-ta/values.xml b/android-car-lib/res/values-ta/values.xml
new file mode 100644
index 0000000..2a7bf98
--- /dev/null
+++ b/android-car-lib/res/values-ta/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"விரிவாக்குவதற்கான/சுருக்குவதற்கான பட்டன்"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"வாகனம் ஓட்டும்போது கவனம் தேவை"</string>
+</resources>
diff --git a/android-car-lib/res/values-te/values-te.xml b/android-car-lib/res/values-te/values-te.xml
new file mode 100644
index 0000000..c4d7d3e
--- /dev/null
+++ b/android-car-lib/res/values-te/values-te.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"రహదారిపై దృష్టి ఉంచండి"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-te/values.xml b/android-car-lib/res/values-te/values.xml
new file mode 100644
index 0000000..082ee94
--- /dev/null
+++ b/android-car-lib/res/values-te/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"విస్తరించు/కుదించు బటన్"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"రహదారిపై దృష్టి ఉంచండి"</string>
+</resources>
diff --git a/android-car-lib/res/values-th/values-th.xml b/android-car-lib/res/values-th/values-th.xml
new file mode 100644
index 0000000..e3fb94f
--- /dev/null
+++ b/android-car-lib/res/values-th/values-th.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"จดจ่อกับถนน"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-th/values.xml b/android-car-lib/res/values-th/values.xml
new file mode 100644
index 0000000..4c7f8ce
--- /dev/null
+++ b/android-car-lib/res/values-th/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"ปุ่มขยาย/ยุบ"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"จดจ่อกับถนน"</string>
+</resources>
diff --git a/android-car-lib/res/values-tl/values-tl.xml b/android-car-lib/res/values-tl/values-tl.xml
new file mode 100644
index 0000000..332c15c
--- /dev/null
+++ b/android-car-lib/res/values-tl/values-tl.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Tumuon sa kalsada"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-tl/values.xml b/android-car-lib/res/values-tl/values.xml
new file mode 100644
index 0000000..674ffb1
--- /dev/null
+++ b/android-car-lib/res/values-tl/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Button na i-expand/i-collapse"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Tumuon sa kalsada"</string>
+</resources>
diff --git a/android-car-lib/res/values-tr/values-tr.xml b/android-car-lib/res/values-tr/values-tr.xml
new file mode 100644
index 0000000..5f66ef3
--- /dev/null
+++ b/android-car-lib/res/values-tr/values-tr.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Dikkatinizi yola verin"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-tr/values.xml b/android-car-lib/res/values-tr/values.xml
new file mode 100644
index 0000000..dde5e18
--- /dev/null
+++ b/android-car-lib/res/values-tr/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Genişlet/daralt düğmesi"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Dikkatinizi yola verin"</string>
+</resources>
diff --git a/android-car-lib/res/values-uk/values-uk.xml b/android-car-lib/res/values-uk/values-uk.xml
new file mode 100644
index 0000000..472d178
--- /dev/null
+++ b/android-car-lib/res/values-uk/values-uk.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Зосередьтеся на дорозі"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-uk/values.xml b/android-car-lib/res/values-uk/values.xml
new file mode 100644
index 0000000..e277cc5
--- /dev/null
+++ b/android-car-lib/res/values-uk/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Кнопка \"Розгорнути або згорнути\""</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Зосередьтеся на дорозі"</string>
+</resources>
diff --git a/android-car-lib/res/values-ur/values-ur.xml b/android-car-lib/res/values-ur/values-ur.xml
new file mode 100644
index 0000000..6f13ae2
--- /dev/null
+++ b/android-car-lib/res/values-ur/values-ur.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"سڑک پر توجہ مرکوز کریں"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-ur/values.xml b/android-car-lib/res/values-ur/values.xml
new file mode 100644
index 0000000..70659bf
--- /dev/null
+++ b/android-car-lib/res/values-ur/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"پھیلائیں/سکیڑیں بٹن"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"سڑک پر توجہ مرکوز کریں"</string>
+</resources>
diff --git a/android-car-lib/res/values-uz/values-uz.xml b/android-car-lib/res/values-uz/values-uz.xml
new file mode 100644
index 0000000..cb5f3aa
--- /dev/null
+++ b/android-car-lib/res/values-uz/values-uz.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Diqqatingizni yo‘lga qarating"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-uz/values.xml b/android-car-lib/res/values-uz/values.xml
new file mode 100644
index 0000000..e9c7755
--- /dev/null
+++ b/android-car-lib/res/values-uz/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Yoyish/yig‘ish tugmasi"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Diqqatingizni yo‘lga qarating"</string>
+</resources>
diff --git a/android-car-lib/res/values-vi/values-vi.xml b/android-car-lib/res/values-vi/values-vi.xml
new file mode 100644
index 0000000..cecbeac
--- /dev/null
+++ b/android-car-lib/res/values-vi/values-vi.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Tập trung vào đường đi"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-vi/values.xml b/android-car-lib/res/values-vi/values.xml
new file mode 100644
index 0000000..070849e
--- /dev/null
+++ b/android-car-lib/res/values-vi/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Nút mở rộng/thu gọn"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Tập trung vào đường đi"</string>
+</resources>
diff --git a/android-car-lib/res/values-w1280dp-v13/values-w1280dp-v13.xml b/android-car-lib/res/values-w1280dp-v13/values-w1280dp-v13.xml
new file mode 100644
index 0000000..e5d29e6
--- /dev/null
+++ b/android-car-lib/res/values-w1280dp-v13/values-w1280dp-v13.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <dimen name="car_keyline_4">182dp</dimen>
+    <dimen name="car_keyline_4_neg">-182dp</dimen>
+    <dimen name="car_margin">148dp</dimen>
+    <integer name="car_dialog_column_number">8</integer>
+    <integer name="column_card_default_column_span">8</integer>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-w1920dp-v13/values-w1920dp-v13.xml b/android-car-lib/res/values-w1920dp-v13/values-w1920dp-v13.xml
new file mode 100644
index 0000000..bcffcfa
--- /dev/null
+++ b/android-car-lib/res/values-w1920dp-v13/values-w1920dp-v13.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <dimen name="car_gutter_size">32dp</dimen>
+    <dimen name="car_keyline_1">48dp</dimen>
+    <dimen name="car_keyline_1_keyline_3_diff">104dp</dimen>
+    <dimen name="car_keyline_1_neg">-48dp</dimen>
+    <dimen name="car_keyline_3">152dp</dimen>
+    <dimen name="car_keyline_3_neg">-152dp</dimen>
+    <dimen name="car_margin">192dp</dimen>
+    <integer name="car_column_number">16</integer>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-w690dp-v13/values-w690dp-v13.xml b/android-car-lib/res/values-w690dp-v13/values-w690dp-v13.xml
new file mode 100644
index 0000000..19864c5
--- /dev/null
+++ b/android-car-lib/res/values-w690dp-v13/values-w690dp-v13.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <dimen name="car_margin">112dp</dimen>
+    <integer name="car_column_number">12</integer>
+    <integer name="car_dialog_column_number">10</integer>
+    <integer name="car_slide_up_menu_column_number">12</integer>
+    <integer name="column_card_default_column_span">12</integer>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-w930dp-v13/values-w930dp-v13.xml b/android-car-lib/res/values-w930dp-v13/values-w930dp-v13.xml
new file mode 100644
index 0000000..363170c
--- /dev/null
+++ b/android-car-lib/res/values-w930dp-v13/values-w930dp-v13.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <dimen name="car_gutter_size">24dp</dimen>
+    <dimen name="car_keyline_1">32dp</dimen>
+    <dimen name="car_keyline_1_keyline_3_diff">96dp</dimen>
+    <dimen name="car_keyline_1_neg">-32dp</dimen>
+    <dimen name="car_keyline_2">108dp</dimen>
+    <dimen name="car_keyline_2_neg">-108dp</dimen>
+    <dimen name="car_keyline_3">128dp</dimen>
+    <dimen name="car_keyline_3_neg">-128dp</dimen>
+    <dimen name="car_keyline_4">168dp</dimen>
+    <dimen name="car_keyline_4_neg">-168dp</dimen>
+    <integer name="car_dialog_column_number">10</integer>
+    <integer name="column_card_default_column_span">10</integer>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-zh-rCN/values-zh-rCN.xml b/android-car-lib/res/values-zh-rCN/values-zh-rCN.xml
new file mode 100644
index 0000000..e3ac7a1
--- /dev/null
+++ b/android-car-lib/res/values-zh-rCN/values-zh-rCN.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"请专心驾驶"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-zh-rCN/values.xml b/android-car-lib/res/values-zh-rCN/values.xml
new file mode 100644
index 0000000..5347850
--- /dev/null
+++ b/android-car-lib/res/values-zh-rCN/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"“展开”/“收起”按钮"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"请专心驾驶"</string>
+</resources>
diff --git a/android-car-lib/res/values-zh-rHK/values-zh-rHK.xml b/android-car-lib/res/values-zh-rHK/values-zh-rHK.xml
new file mode 100644
index 0000000..37107e1
--- /dev/null
+++ b/android-car-lib/res/values-zh-rHK/values-zh-rHK.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"請專心駕駛"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-zh-rHK/values.xml b/android-car-lib/res/values-zh-rHK/values.xml
new file mode 100644
index 0000000..b190714
--- /dev/null
+++ b/android-car-lib/res/values-zh-rHK/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"展開/收合按鈕"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"請專心駕駛"</string>
+</resources>
diff --git a/android-car-lib/res/values-zh-rTW/values-zh-rTW.xml b/android-car-lib/res/values-zh-rTW/values-zh-rTW.xml
new file mode 100644
index 0000000..37107e1
--- /dev/null
+++ b/android-car-lib/res/values-zh-rTW/values-zh-rTW.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"請專心駕駛"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-zh-rTW/values.xml b/android-car-lib/res/values-zh-rTW/values.xml
new file mode 100644
index 0000000..b190714
--- /dev/null
+++ b/android-car-lib/res/values-zh-rTW/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"展開/收合按鈕"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"請專心駕駛"</string>
+</resources>
diff --git a/android-car-lib/res/values-zu/values-zu.xml b/android-car-lib/res/values-zu/values-zu.xml
new file mode 100644
index 0000000..1f93364
--- /dev/null
+++ b/android-car-lib/res/values-zu/values-zu.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string msgid="5405697774899378511" name="speed_bump_lockout_message">"Gxila emgwaqweni"</string>
+</resources>
\ No newline at end of file
diff --git a/android-car-lib/res/values-zu/values.xml b/android-car-lib/res/values-zu/values.xml
new file mode 100644
index 0000000..0646429
--- /dev/null
+++ b/android-car-lib/res/values-zu/values.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="action_bar_expand_collapse_button" msgid="2901704611804567760">"Inkinobho yokunweba/ukugoqa"</string>
+    <string name="speed_bump_lockout_message" msgid="4050134640025645838">"Gxila emgwaqeni"</string>
+</resources>
diff --git a/android-car-lib/res/values/values.xml b/android-car-lib/res/values/values.xml
new file mode 100644
index 0000000..0ae2c80
--- /dev/null
+++ b/android-car-lib/res/values/values.xml
@@ -0,0 +1,546 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="car_accent">@color/car_accent_dark</color>
+    <color name="car_accent_dark">@color/car_teal_700</color>
+    <color name="car_accent_light">@color/car_teal_200</color>
+    <color name="car_action1">@color/car_action1_dark</color>
+    <color name="car_action1_dark">@color/car_grey_50</color>
+    <color name="car_action1_light">@color/car_grey_900</color>
+    <color name="car_blue_300">#ff91a7ff</color>
+    <color name="car_blue_500">#ff5677fc</color>
+    <color name="car_blue_grey_800">#ff37474F</color>
+    <color name="car_blue_grey_900">#ff263238</color>
+    <color name="car_body1">@color/car_body1_dark</color>
+    <color name="car_body1_dark">@color/car_grey_900</color>
+    <color name="car_body1_light">@color/car_grey_100</color>
+    <color name="car_body2">@color/car_body2_dark</color>
+    <color name="car_body2_dark">@color/car_grey_650</color>
+    <color name="car_body2_light">@color/car_grey_300</color>
+    <color name="car_body3">@color/car_body3_dark</color>
+    <color name="car_body3_dark">@android:color/black</color>
+    <color name="car_body3_light">@android:color/white</color>
+    <color name="car_body4">@color/car_body4_dark</color>
+    <color name="car_body4_dark">@android:color/black</color>
+    <color name="car_body4_light">@android:color/white</color>
+    <color name="car_card">@color/car_card_light</color>
+    <color name="car_card_dark">@color/car_dark_blue_grey_700</color>
+    <color name="car_card_inverse">@color/car_card_dark</color>
+    <color name="car_card_light">@color/car_grey_50</color>
+    <color name="car_card_ripple_background">@color/car_card_ripple_background_dark</color>
+    <color name="car_card_ripple_background_dark">#8F000000</color>
+    <color name="car_card_ripple_background_inverse">@color/car_card_ripple_background_light</color>
+    <color name="car_card_ripple_background_light">#27ffffff</color>
+    <color name="car_dark_blue_grey_1000">#ff090c0f</color>
+    <color name="car_dark_blue_grey_600">#ff1d272d</color>
+    <color name="car_dark_blue_grey_700">#ff172026</color>
+    <color name="car_dark_blue_grey_800">#ff11181d</color>
+    <color name="car_dark_blue_grey_900">#ff0c1013</color>
+    <color name="car_green_500">#ff0f9d58</color>
+    <color name="car_green_700">#ff0b8043</color>
+    <color name="car_grey_100">#fff5f5f5</color>
+    <color name="car_grey_1000">#cc000000</color>
+    <color name="car_grey_200">#ffeeeeee</color>
+    <color name="car_grey_300">#ffe0e0e0</color>
+    <color name="car_grey_400">#ffbdbdbd</color>
+    <color name="car_grey_50">#fffafafa</color>
+    <color name="car_grey_500">#ff9e9e9e</color>
+    <color name="car_grey_600">#ff757575</color>
+    <color name="car_grey_650">#ff6B6B6B</color>
+    <color name="car_grey_700">#ff616161</color>
+    <color name="car_grey_800">#ff424242</color>
+    <color name="car_grey_900">#ff212121</color>
+    <color name="car_headline1">@color/car_headline1_dark</color>
+    <color name="car_headline1_dark">@color/car_grey_800</color>
+    <color name="car_headline1_light">@color/car_grey_100</color>
+    <color name="car_headline2">@color/car_headline2_dark</color>
+    <color name="car_headline2_dark">@color/car_grey_900</color>
+    <color name="car_headline2_light">@color/car_grey_100</color>
+    <color name="car_headline3">@color/car_headline3_dark</color>
+    <color name="car_headline3_dark">@color/car_grey_900</color>
+    <color name="car_headline3_light">@android:color/white</color>
+    <color name="car_headline4">@color/car_headline4_dark</color>
+    <color name="car_headline4_dark">@android:color/black</color>
+    <color name="car_headline4_light">@android:color/white</color>
+    <color name="car_highlight">@color/car_highlight_light</color>
+    <color name="car_highlight_dark">@color/car_teal_200</color>
+    <color name="car_highlight_light">@color/car_teal_700</color>
+    <color name="car_indigo_800">#ff283593</color>
+    <color name="car_label1">@color/car_label1_dark</color>
+    <color name="car_label1_dark">@color/car_grey_900</color>
+    <color name="car_label1_light">@color/car_grey_50</color>
+    <color name="car_light_blue_300">#ff4fc3f7</color>
+    <color name="car_light_blue_500">#ff03A9F4</color>
+    <color name="car_light_blue_600">#ff039be5</color>
+    <color name="car_light_blue_700">#ff0288d1</color>
+    <color name="car_light_blue_800">#ff0277bd</color>
+    <color name="car_light_blue_900">#ff01579b</color>
+    <color name="car_list_divider">@color/car_list_divider_dark</color>
+    <color name="car_list_divider_dark">#1f000000</color>
+    <color name="car_list_divider_inverse">@color/car_list_divider_light</color>
+    <color name="car_list_divider_light">#1fffffff</color>
+    <color name="car_list_header">@color/car_blue_500</color>
+    <color name="car_red_400">#ffe06055</color>
+    <color name="car_red_500">#ffdb4437</color>
+    <color name="car_red_500a">#ffd50000</color>
+    <color name="car_red_700">#ffc53929</color>
+    <color name="car_scrollbar_thumb">@color/car_scrollbar_thumb_dark</color>
+    <color name="car_scrollbar_thumb_dark">#7f0b0f12</color>
+    <color name="car_scrollbar_thumb_inverse">@color/car_scrollbar_thumb_light</color>
+    <color name="car_scrollbar_thumb_light">#99ffffff</color>
+    <color name="car_seekbar_track_background">@color/car_seekbar_track_background_dark</color>
+    <color name="car_seekbar_track_background_dark">@color/car_grey_700</color>
+    <color name="car_seekbar_track_background_inverse"> @color/car_seekbar_track_background_light
+    </color>
+    <color name="car_seekbar_track_background_light">@color/car_grey_400</color>
+    <color name="car_teal_200">#ff80cbc4</color>
+    <color name="car_teal_700">#ff00796b</color>
+    <color name="car_tint">@color/car_tint_dark</color>
+    <color name="car_tint_dark">@color/car_grey_900</color>
+    <color name="car_tint_inverse">@color/car_tint_light</color>
+    <color name="car_tint_light">@color/car_grey_50</color>
+    <color name="car_title">@color/car_title_dark</color>
+    <color name="car_title2">@color/car_title2_dark</color>
+    <color name="car_title2_dark">@color/car_grey_900</color>
+    <color name="car_title2_light">@color/car_grey_100</color>
+    <color name="car_title_dark">@color/car_grey_900</color>
+    <color name="car_title_light">@color/car_grey_100</color>
+    <color name="car_white_1000">#1effffff</color>
+    <color name="car_yellow_500">#fff4b400</color>
+    <color name="car_yellow_800">#ffee8100</color>
+    <color name="speed_bump_background">#FFD0D0D0</color>
+    <declare-styleable name="ActionBar"><attr format="integer" name="columns"/></declare-styleable>
+    <declare-styleable name="CarTheme"><attr format="reference" name="carDialogTheme"/><attr format="reference" name="pagedListViewStyle"/><attr format="reference" name="listItemStyle"/><attr format="color" name="dialogBackgroundColor"/><attr format="reference" name="dialogTitleStyle"/><attr format="reference" name="dialogBodyStyle"/><attr format="reference" name="dialogButtonStyle"/><attr format="reference" name="dialogListTheme"/><attr format="color" name="drawerBackgroundColor"/><attr format="color" name="drawerOpenHeaderColor"/><attr format="color" name="drawerClosedHeaderColor"/><attr format="reference" name="drawerItemTitleTextAppearance"/><attr format="reference" name="drawerItemBodyTextAppearance"/><attr format="reference" name="drawerListStyle"/></declare-styleable>
+    <declare-styleable name="ClickThroughToolbar"><attr format="boolean" name="clickThrough"/></declare-styleable>
+    <declare-styleable name="ColumnCardView"><attr format="integer" name="columnSpan"/></declare-styleable>
+    <declare-styleable name="DrawerArrowDrawable"><attr format="color" name="carArrowColor"/><attr format="boolean" name="carArrowAnimate"/><attr format="dimension" name="carArrowSize"/><attr format="dimension" name="carArrowHeadLength"/><attr format="dimension" name="carArrowShaftLength"/><attr format="dimension" name="carArrowThickness"/><attr format="dimension" name="carMenuBarSpacing"/><attr format="dimension" name="carMenuBarThickness"/></declare-styleable>
+    <declare-styleable name="ListItem"><attr format="color" name="listItemBackgroundColor"/><attr format="reference" name="listItemTitleTextAppearance"/><attr format="reference" name="listItemBodyTextAppearance"/></declare-styleable>
+    <declare-styleable name="PagedListView"><attr format="boolean" name="offsetScrollBar"/><attr format="enum" name="gutter">
+            
+            <enum name="none" value="0"/>
+            
+            <enum name="start" value="1"/>
+            
+            <enum name="end" value="2"/>
+            
+            <enum name="both" value="3"/>
+        </attr><attr format="dimension" name="gutterSize"/><attr format="boolean" name="scrollBarEnabled"/><attr format="dimension" name="scrollBarTopMargin"/><attr format="dimension" name="scrollBarContainerWidth"/><attr format="boolean" name="showPagedListViewDivider"/><attr format="reference" name="alignDividerStartTo"/><attr format="reference" name="alignDividerEndTo"/><attr format="dimension" name="dividerStartMargin"/><attr format="dimension" name="dividerEndMargin"/><attr format="color" name="listDividerColor"/><attr format="dimension" name="listEndMargin"/><attr format="dimension" name="itemSpacing"/><attr format="reference" name="upButtonIcon"/><attr format="reference" name="downButtonIcon"/><attr format="reference" name="listContentTopOffset"/><attr format="enum" name="dayNightStyle">
+            
+            <enum name="auto" value="0"/>
+            
+            <enum name="auto_inverse" value="1"/>
+            
+            <enum name="force_night" value="2"/>
+            
+            <enum name="force_day" value="3"/>
+        </attr></declare-styleable>
+    <dimen name="app_header_height">96dp</dimen>
+    <dimen name="car_action1_size">26sp</dimen>
+    <dimen name="car_action_bar_activation_ring_radius">64dp</dimen>
+    <dimen name="car_action_bar_activation_ring_stroke_width">3dp</dimen>
+    <dimen name="car_action_bar_button_height">128dp</dimen>
+    <dimen name="car_action_bar_button_ripple_radius">48dp</dimen>
+    <dimen name="car_action_bar_button_width">128dp</dimen>
+    <dimen name="car_action_bar_buttons_space">@dimen/car_padding_4</dimen>
+    <dimen name="car_action_bar_elevation">2dp</dimen>
+    <dimen name="car_action_bar_height">128dp</dimen>
+    <dimen name="car_action_bar_touch_ripple_size">38dp</dimen>
+    <dimen name="car_action_button_icon_inset">24dp</dimen>
+    <dimen name="car_action_button_ripple_inset">16dp</dimen>
+    <dimen name="car_alpha_jump_button_size">@dimen/car_scroll_bar_button_size</dimen>
+    <dimen name="car_app_bar_default_elevation">8dp</dimen>
+    <dimen name="car_app_bar_height">80dp</dimen>
+    <dimen name="car_arrow_head_length">18dp</dimen>
+    <dimen name="car_arrow_shaft_length">34dp</dimen>
+    <dimen name="car_arrow_size">96dp</dimen>
+    <dimen name="car_arrow_thickness">3dp</dimen>
+    <dimen name="car_avatar_size">56dp</dimen>
+    <dimen name="car_body1_size">32sp</dimen>
+    <dimen name="car_body2_size">26sp</dimen>
+    <dimen name="car_body3_size">16sp</dimen>
+    <dimen name="car_body4_size">14sp</dimen>
+    <dimen name="car_body5_size">18sp</dimen>
+    <dimen name="car_borderless_button_horizontal_padding">0dp</dimen>
+    <dimen name="car_button_height">56dp</dimen>
+    <dimen name="car_button_horizontal_padding">@dimen/car_padding_4</dimen>
+    <dimen name="car_button_min_width">158dp</dimen>
+    <dimen name="car_button_radius">@dimen/car_radius_1</dimen>
+    <dimen name="car_card_action_bar_height">76dp</dimen>
+    <dimen name="car_card_header_height">76dp</dimen>
+    <dimen name="car_dialog_action_bar_height">@dimen/car_card_action_bar_height</dimen>
+    <dimen name="car_dialog_elevation">16dp</dimen>
+    <dimen name="car_dialog_header_height">@dimen/car_card_header_height</dimen>
+    <dimen name="car_double_line_list_item_height">@dimen/car_single_line_list_item_height</dimen>
+    <dimen name="car_drawer_list_item_end_icon_size">56dp</dimen>
+    <dimen name="car_drawer_list_item_end_margin">32dp</dimen>
+    <dimen name="car_drawer_list_item_icon_end_margin">32dp</dimen>
+    <dimen name="car_drawer_list_item_icon_size">64dp</dimen>
+    <dimen name="car_drawer_list_item_small_icon_size">56dp</dimen>
+    <dimen name="car_drawer_margin_end">96dp</dimen>
+    <dimen name="car_drawer_progress_bar_size">48dp</dimen>
+    <dimen name="car_gutter_size">16dp</dimen>
+    <dimen name="car_headline1_size">45sp</dimen>
+    <dimen name="car_headline2_size">32sp</dimen>
+    <dimen name="car_headline3_size">24sp</dimen>
+    <dimen name="car_headline4_size">20sp</dimen>
+    <dimen name="car_keyline_1">24dp</dimen>
+    <dimen name="car_keyline_1_keyline_3_diff">88dp</dimen>
+    <dimen name="car_keyline_1_neg">-24dp</dimen>
+    <dimen name="car_keyline_2">96dp</dimen>
+    <dimen name="car_keyline_2_neg">-96dp</dimen>
+    <dimen name="car_keyline_3">112dp</dimen>
+    <dimen name="car_keyline_3_neg">-112dp</dimen>
+    <dimen name="car_keyline_4">148dp</dimen>
+    <dimen name="car_keyline_4_neg">-148dp</dimen>
+    <dimen name="car_label1_size">26sp</dimen>
+    <dimen name="car_last_card_peek_amount">16dp</dimen>
+    <dimen name="car_list_divider_height">1dp</dimen>
+    <dimen name="car_margin">20dp</dimen>
+    <dimen name="car_menu_bar_length">40dp</dimen>
+    <dimen name="car_menu_bar_spacing">6dp</dimen>
+    <dimen name="car_padding_0">4dp</dimen>
+    <dimen name="car_padding_1">10dp</dimen>
+    <dimen name="car_padding_2">12dp</dimen>
+    <dimen name="car_padding_3">16dp</dimen>
+    <dimen name="car_padding_4">20dp</dimen>
+    <dimen name="car_padding_5">40dp</dimen>
+    <dimen name="car_padding_6">64dp</dimen>
+    <dimen name="car_primary_icon_size">44dp</dimen>
+    <dimen name="car_progress_bar_height">@dimen/car_seekbar_height</dimen>
+    <dimen name="car_radius_1">4dp</dimen>
+    <dimen name="car_radius_2">8dp</dimen>
+    <dimen name="car_radius_3">16dp</dimen>
+    <dimen name="car_radius_5">100dp</dimen>
+    <dimen name="car_sample_row_height">128dp</dimen>
+    <dimen name="car_scroll_bar_button_size">56dp</dimen>
+    <dimen name="car_scroll_bar_thumb_width">6dp</dimen>
+    <dimen name="car_secondary_icon_size">24dp</dimen>
+    <dimen name="car_seekbar_height">6dp</dimen>
+    <dimen name="car_seekbar_thumb_size">20dp</dimen>
+    <dimen name="car_seekbar_thumb_stroke">1dp</dimen>
+    <dimen name="car_single_line_list_item_height">96dp</dimen>
+    <dimen name="car_slide_down_menu_initial_height">@dimen/car_slide_up_menu_initial_height</dimen>
+    <dimen name="car_slide_up_menu_initial_height">76dp</dimen>
+    <dimen name="car_sub_header_height">76dp</dimen>
+    <dimen name="car_text_input_line_height">2dp</dimen>
+    <dimen name="car_text_vertical_margin">2dp</dimen>
+    <dimen name="car_title2_size">32sp</dimen>
+    <dimen name="car_title_size">32sp</dimen>
+    <dimen name="car_touch_target_size">76dp</dimen>
+    <dimen name="car_vertical_line_divider_height">60dp</dimen>
+    <dimen name="car_vertical_line_divider_width">1dp</dimen>
+    <dimen name="speed_bump_lock_out_drawable_margin_bottom">8dp</dimen>
+    <dimen name="speed_bump_lock_out_message_height">96dp</dimen>
+    <integer name="car_action_bar_collapse_anim_duration">233</integer>
+    <integer name="car_action_bar_expand_anim_duration">333</integer>
+    <integer name="car_borderless_button_text_length_limit">20</integer>
+    <integer name="car_column_number">4</integer>
+    <integer name="car_dialog_column_number">10</integer>
+    <integer name="car_list_item_text_length_limit">120</integer>
+    <integer name="car_slide_up_menu_column_number">4</integer>
+    <integer name="column_card_default_column_span">4</integer>
+    <integer name="speed_bump_fade_duration_ms">167</integer>
+    <integer name="speed_bump_lock_out_color_change_ms">500</integer>
+    <integer name="speed_bump_lock_out_color_change_start_delay_ms">5433</integer>
+    <integer name="speed_bump_lock_out_duration_ms">5933</integer>
+    <integer name="speed_bump_translate_y_duration_ms">300</integer>
+    <string name="action_bar_expand_collapse_button">Expand/collapse button</string>
+    <string name="car_drawer_close" translatable="false">Close drawer</string>
+    <string name="car_drawer_open" translatable="false">Open drawer</string>
+    <string name="ellipsis" translatable="false">…</string>
+    <string name="speed_bump_lockout_message">Focus on the road</string>
+    <style name="CarListVerticalDivider">
+        <item name="android:layout_width">@dimen/car_vertical_line_divider_width</item>
+        <item name="android:layout_height">@dimen/car_vertical_line_divider_height</item>
+        <item name="android:layout_marginStart">@dimen/car_padding_4</item>
+        <item name="android:background">@color/car_list_divider</item>
+    </style>
+    <style name="TextAppearance.Car" parent="TextAppearance.AppCompat"/>
+    <style name="TextAppearance.Car.Body1">
+        <item name="android:textStyle">normal</item>
+        <item name="android:textSize">@dimen/car_body1_size</item>
+        <item name="android:textColor">@color/car_body1</item>
+    </style>
+    <style name="TextAppearance.Car.Body1.Dark">
+        <item name="android:textColor">@color/car_body2_dark</item>
+    </style>
+    <style name="TextAppearance.Car.Body1.Light">
+        <item name="android:textColor">@color/car_body1_light</item>
+    </style>
+    <style name="TextAppearance.Car.Body2">
+        <item name="android:textStyle">normal</item>
+        <item name="android:textSize">@dimen/car_body2_size</item>
+        <item name="android:textColor">@color/car_body2</item>
+    </style>
+    <style name="TextAppearance.Car.Body2.Dark">
+        <item name="android:textColor">@color/car_body2_dark</item>
+    </style>
+    <style name="TextAppearance.Car.Body2.Light">
+        <item name="android:textColor">@color/car_body2_light</item>
+    </style>
+    <style name="TextAppearance.Car.Body3">
+        <item name="android:textStyle">normal</item>
+        <item name="android:textSize">@dimen/car_body3_size</item>
+        <item name="android:textColor">@color/car_body3</item>
+    </style>
+    <style name="TextAppearance.Car.Body4">
+        <item name="android:textStyle">normal</item>
+        <item name="android:textSize">@dimen/car_body4_size</item>
+        <item name="android:textColor">@color/car_body4</item>
+    </style>
+    <style name="TextAppearance.Car.Headline1">
+        <item name="android:textStyle">normal</item>
+        <item name="android:textSize">@dimen/car_headline1_size</item>
+        <item name="android:textColor">@color/car_headline1</item>
+    </style>
+    <style name="TextAppearance.Car.Headline1.Dark">
+        <item name="android:textColor">@color/car_headline1_dark</item>
+    </style>
+    <style name="TextAppearance.Car.Headline1.Light">
+        <item name="android:textColor">@color/car_headline1_light</item>
+    </style>
+    <style name="TextAppearance.Car.Headline2">
+        <item name="android:textStyle">normal</item>
+        <item name="android:textSize">@dimen/car_headline2_size</item>
+        <item name="android:textColor">@color/car_headline2</item>
+    </style>
+    <style name="TextAppearance.Car.Headline3">
+        <item name="android:textStyle">normal</item>
+        <item name="android:textSize">@dimen/car_headline3_size</item>
+        <item name="android:textColor">@color/car_headline3</item>
+    </style>
+    <style name="TextAppearance.Car.Headline4">
+        <item name="android:textStyle">normal</item>
+        <item name="android:textSize">@dimen/car_headline4_size</item>
+        <item name="android:textColor">@color/car_headline4</item>
+    </style>
+    <style name="TextAppearance.Car.Hint" parent="TextAppearance.Car.Body2"/>
+    <style name="TextAppearance.Car.Label1">
+        <item name="android:textStyle">normal</item>
+        <item name="android:textSize">@dimen/car_label1_size</item>
+        <item name="android:textColor">@color/car_label1</item>
+    </style>
+    <style name="TextAppearance.Car.Title">
+        <item name="android:fontFamily">sans-serif-medium</item>
+        <item name="android:textStyle">normal</item>
+        <item name="android:textSize">@dimen/car_title_size</item>
+        <item name="android:textColor">@color/car_title</item>
+    </style>
+    <style name="TextAppearance.Car.Title.Dark">
+        <item name="android:textColor">@color/car_title_dark</item>
+    </style>
+    <style name="TextAppearance.Car.Title.Light">
+        <item name="android:textColor">@color/car_title_light</item>
+    </style>
+    <style name="TextAppearance.Car.Title2">
+        <item name="android:fontFamily">sans-serif-medium</item>
+        <item name="android:textStyle">normal</item>
+        <item name="android:textSize">@dimen/car_title2_size</item>
+        <item name="android:textColor">@color/car_title2</item>
+    </style>
+    <style name="TextAppearance.Car.Title2.Dark">
+        <item name="android:textColor">@color/car_title2_dark</item>
+    </style>
+    <style name="TextAppearance.Car.Title2.Light">
+        <item name="android:textColor">@color/car_title2_light</item>
+    </style>
+    <style name="Theme.Car.Dark.Dialog" parent="Theme.Car.Dialog">
+        <item name="dialogButtonStyle">@style/Widget.Car.Button.Borderless.Colored</item>
+        <item name="dialogBackgroundColor">@color/car_card_dark</item>
+        <item name="dialogListTheme">@style/Theme.Car.Light.List.DarkItems</item>
+        <item name="dialogTitleStyle">@style/Widget.Car.Dialog.Title.Light</item>
+        <item name="dialogBodyStyle">@style/Widget.Car.Dialog.Body.Light</item>
+    </style>
+    <style name="Theme.Car.Dark.Dialog.Alert" parent="Theme.Car.Dialog.Alert">
+        <item name="android:background">@color/car_card_dark</item>
+        <item name="android:listDividerAlertDialog">@drawable/car_list_divider_light</item>
+        <item name="android:textColorPrimary">@color/car_body2_light</item>
+        <item name="android:windowTitleStyle">@style/Widget.Car.Dialog.Title.Light</item>
+    </style>
+    <style name="Theme.Car.Dark.NoActionBar" parent="Theme.Car.NoActionBar">
+        <item name="android:alertDialogTheme">@style/Theme.Car.Dark.Dialog.Alert</item>
+        <item name="alertDialogTheme">@style/Theme.Car.Dark.Dialog.Alert</item>
+        <item name="carDialogTheme">@style/Theme.Car.Dark.Dialog</item>
+        <item name="pagedListViewStyle">@style/Widget.Car.Light.List.LightDivider</item>
+        <item name="listItemStyle">@style/Widget.Car.ListItem.Dark</item>
+    </style>
+    <style name="Theme.Car.Dark.NoActionBar.Drawer">
+        <item name="drawerArrowStyle">@style/Widget.Car.DrawerArrowToggle</item>
+        <item name="drawerBackgroundColor">@color/car_card_dark</item>
+        <item name="drawerOpenHeaderColor">@color/car_title2_light</item>
+        <item name="drawerClosedHeaderColor">@color/car_title2_light</item>
+        <item name="drawerItemTitleTextAppearance">@style/TextAppearance.Car.Body1.Light</item>
+        <item name="drawerItemBodyTextAppearance">@style/TextAppearance.Car.Body2.Light</item>
+        <item name="drawerListStyle">@style/Widget.Car.Light.List.LightDivider</item>
+    </style>
+    <style name="Theme.Car.Dialog" parent="Theme.AppCompat.Dialog">
+        <item name="android:windowIsTranslucent">true</item>
+        <item name="android:windowBackground">@android:color/transparent</item>
+        <item name="dialogButtonStyle">@style/Widget.Car.Button.Borderless.Colored</item>
+        <item name="dialogBackgroundColor">@color/car_card</item>
+        <item name="dialogListTheme">@style/Theme.Car.List</item>
+        <item name="dialogTitleStyle">@style/Widget.Car.Dialog.Title</item>
+        <item name="dialogBodyStyle">@style/Widget.Car.Dialog.Body</item>
+    </style>
+    <style name="Theme.Car.Dialog.Alert" parent="Theme.AppCompat.Dialog.Alert">
+        <item name="android:background">@color/car_card</item>
+        <item name="android:borderlessButtonStyle">@style/Widget.Car.Button.Borderless.Colored</item>
+        <item name="android:colorButtonNormal">@color/car_accent</item>
+        <item name="android:listDividerAlertDialog">@drawable/car_list_divider</item>
+        <item name="android:textColorPrimary">@color/car_body2</item>
+        <item name="android:windowTitleStyle">@style/Widget.Car.Dialog.Title</item>
+        <item name="buttonBarNeutralButtonStyle">@style/Widget.Car.Button.Borderless.Colored</item>
+        <item name="buttonBarNegativeButtonStyle">@style/Widget.Car.Button.Borderless.Colored</item>
+        <item name="buttonBarPositiveButtonStyle">@style/Widget.Car.Button.Borderless.Colored</item>
+    </style>
+    <style name="Theme.Car.Light.Dialog.Alert" parent="Theme.Car.Dialog.Alert">
+        <item name="android:background">@color/car_card_light</item>
+        <item name="android:listDividerAlertDialog">@drawable/car_list_divider_dark</item>
+        <item name="android:textColorPrimary">@color/car_body2_dark</item>
+        <item name="android:windowTitleStyle">@style/Widget.Car.Dialog.Title.Dark</item>
+    </style>
+    <style name="Theme.Car.Light.List" parent="Theme.Car.List">
+        <item name="pagedListViewStyle">@style/Widget.Car.Light.List.LightDivider</item>
+    </style>
+    <style name="Theme.Car.Light.List.DarkItems">
+        <item name="listItemStyle">@style/Widget.Car.ListItem.Dark</item>
+    </style>
+    <style name="Theme.Car.Light.NoActionBar" parent="Theme.Car.NoActionBar"/>
+    <style name="Theme.Car.Light.NoActionBar.Drawer" parent="Theme.Car.NoActionBar.Drawer"/>
+    <style name="Theme.Car.List" parent="android:Theme">
+        <item name="pagedListViewStyle">@style/Widget.Car.List</item>
+        <item name="listItemStyle">@style/Widget.Car.ListItem</item>
+    </style>
+    <style name="Theme.Car.NoActionBar" parent="Theme.AppCompat.NoActionBar">
+        <item name="android:colorAccent">@color/car_accent</item>
+        <item name="android:colorButtonNormal">@color/car_accent</item>
+        <item name="android:buttonStyle">@style/Widget.Car.Button</item>
+        <item name="android:borderlessButtonStyle">@style/Widget.Car.Button.Borderless.Colored</item>
+        <item name="android:progressBarStyleHorizontal">@style/Widget.Car.ProgressBar.Horizontal</item>
+        <item name="android:textColorHint">@color/car_body2</item>
+        <item name="android:editTextStyle">@style/Widget.Car.EditText</item>
+        <item name="android:editTextColor">@color/car_body1</item>
+        <item name="android:colorControlNormal">@color/car_body2</item>
+        <item name="carDialogTheme">@style/Theme.Car.Dialog</item>
+        <item name="pagedListViewStyle">@style/Widget.Car.List</item>
+        <item name="listItemStyle">@style/Widget.Car.ListItem</item>
+    </style>
+    <style name="Theme.Car.NoActionBar.Drawer">
+        <item name="drawerArrowStyle">@style/Widget.Car.DrawerArrowToggle</item>
+        <item name="drawerBackgroundColor">@color/car_card</item>
+        <item name="drawerOpenHeaderColor">@color/car_title2</item>
+        <item name="drawerClosedHeaderColor">@color/car_title2_light</item>
+        <item name="drawerItemTitleTextAppearance">@style/TextAppearance.Car.Body1</item>
+        <item name="drawerItemBodyTextAppearance">@style/TextAppearance.Car.Body2</item>
+        <item name="drawerListStyle">@style/Widget.Car.List</item>
+    </style>
+    <style name="Widget.Car.Button" parent="Widget.AppCompat.Button">
+        <item name="android:fontFamily">sans-serif-medium</item>
+        <item name="android:layout_height">@dimen/car_button_height</item>
+        <item name="android:minWidth">@dimen/car_button_min_width</item>
+        <item name="android:paddingStart">@dimen/car_button_horizontal_padding</item>
+        <item name="android:paddingEnd">@dimen/car_button_horizontal_padding</item>
+        <item name="android:textSize">@dimen/car_action1_size</item>
+        <item name="android:background">@drawable/car_button_background</item>
+        <item name="android:textColor">@drawable/car_button_text_color</item>
+    </style>
+    <style name="Widget.Car.Button.ActionBar">
+        <item name="android:scaleType">fitCenter</item>
+        <item name="android:padding">@dimen/car_action_button_icon_inset</item>
+        <item name="android:background">@drawable/car_action_button_background</item>
+        <item name="android:tint">@color/car_tint</item>
+    </style>
+    <style name="Widget.Car.Button.Borderless.Colored" parent="Widget.AppCompat.Button.Borderless.Colored">
+        <item name="android:fontFamily">sans-serif-medium</item>
+        <item name="android:layout_height">@dimen/car_button_height</item>
+        <item name="android:minWidth">@dimen/car_button_min_width</item>
+        <item name="android:paddingStart">@dimen/car_borderless_button_horizontal_padding</item>
+        <item name="android:paddingEnd">@dimen/car_borderless_button_horizontal_padding</item>
+        <item name="android:textSize">@dimen/car_action1_size</item>
+        <item name="android:textColor">@drawable/car_borderless_button_text_color</item>
+    </style>
+    <style name="Widget.Car.Button.Borderless.Colored.Dark">
+        <item name="android:textColor">@drawable/car_borderless_button_text_color</item>
+    </style>
+    <style name="Widget.Car.Button.Borderless.Colored.Light">
+        <item name="android:textColor">@drawable/car_borderless_button_text_color</item>
+    </style>
+    <style name="Widget.Car.Dark.List" parent="Widget.Car.List">
+        <item name="dayNightStyle">force_day</item>
+    </style>
+    <style name="Widget.Car.Dark.List.LightDivider">
+        <item name="listDividerColor">@color/car_list_divider_light</item>
+    </style>
+    <style name="Widget.Car.Dialog" parent="android:Widget"/>
+    <style name="Widget.Car.Dialog.Body">
+        <item name="android:textAppearance">@style/TextAppearance.Car.Body2</item>
+    </style>
+    <style name="Widget.Car.Dialog.Body.Dark">
+        <item name="android:textAppearance">@style/TextAppearance.Car.Body2.Dark</item>
+    </style>
+    <style name="Widget.Car.Dialog.Body.Light">
+        <item name="android:textAppearance">@style/TextAppearance.Car.Body2.Light</item>
+    </style>
+    <style name="Widget.Car.Dialog.Title">
+        <item name="android:maxLines">1</item>
+        <item name="android:textAppearance">@style/TextAppearance.Car.Title2</item>
+        <item name="android:ellipsize">end</item>
+        <item name="android:textAlignment">viewStart</item>
+    </style>
+    <style name="Widget.Car.Dialog.Title.Dark">
+        <item name="android:textAppearance">@style/TextAppearance.Car.Title2.Dark</item>
+    </style>
+    <style name="Widget.Car.Dialog.Title.Light">
+        <item name="android:textAppearance">@style/TextAppearance.Car.Title2.Light</item>
+    </style>
+    <style name="Widget.Car.DrawerArrowToggle" parent="Widget.AppCompat.DrawerArrowToggle">
+        <item name="color">@color/car_title_light</item>
+        <item name="spinBars">true</item>
+        <item name="barLength">@dimen/car_menu_bar_length</item>
+        <item name="thickness">@dimen/car_arrow_thickness</item>
+        <item name="gapBetweenBars">@dimen/car_menu_bar_spacing</item>
+        <item name="arrowShaftLength">@dimen/car_arrow_shaft_length</item>
+        <item name="arrowHeadLength">@dimen/car_arrow_head_length</item>
+        <item name="drawableSize">@dimen/car_arrow_size</item>
+    </style>
+    <style name="Widget.Car.EditText" parent="Widget.AppCompat.EditText">
+        <item name="android:textColor">?attr/editTextColor</item>
+        <item name="android:textAppearance">@style/TextAppearance.Car.Body1</item>
+    </style>
+    <style name="Widget.Car.Light.List" parent="Widget.Car.List">
+        <item name="dayNightStyle">force_night</item>
+    </style>
+    <style name="Widget.Car.Light.List.LightDivider">
+        <item name="listDividerColor">@color/car_list_divider_light</item>
+    </style>
+    <style name="Widget.Car.List" parent="android:Widget">
+        <item name="dayNightStyle">auto</item>
+        <item name="listDividerColor">@color/car_list_divider</item>
+    </style>
+    <style name="Widget.Car.List.Inverse">
+        <item name="dayNightStyle">auto_inverse</item>
+        <item name="listDividerColor">@color/car_list_divider_inverse</item>
+    </style>
+    <style name="Widget.Car.ListItem" parent="android:Widget">
+        <item name="listItemBackgroundColor">@color/car_card</item>
+        <item name="listItemTitleTextAppearance">@style/TextAppearance.Car.Body1</item>
+        <item name="listItemBodyTextAppearance">@style/TextAppearance.Car.Body2</item>
+    </style>
+    <style name="Widget.Car.ListItem.Dark">
+        <item name="listItemBackgroundColor">@color/car_card_dark</item>
+        <item name="listItemTitleTextAppearance">@style/TextAppearance.Car.Body1.Light</item>
+        <item name="listItemBodyTextAppearance">@style/TextAppearance.Car.Body2.Light</item>
+    </style>
+    <style name="Widget.Car.ProgressBar.Horizontal" parent="Widget.AppCompat.ProgressBar.Horizontal">
+        <item name="android:minHeight">@dimen/car_progress_bar_height</item>
+        <item name="android:maxHeight">@dimen/car_progress_bar_height</item>
+    </style>
+    <style name="Widget.Car.SeekBar" parent="Widget.AppCompat.SeekBar">
+        <item name="android:progressDrawable">@drawable/car_seekbar_track</item>
+        <item name="android:thumb">@drawable/car_seekbar_thumb</item>
+    </style>
+    <style name="Widget.Car.Toolbar" parent="Widget.AppCompat.Toolbar">
+        <item name="titleTextAppearance">@style/TextAppearance.Car.Title.Light</item>
+        <item name="contentInsetStart">@dimen/car_keyline_1</item>
+        <item name="contentInsetEnd">@dimen/car_keyline_1</item>
+    </style>
+</resources>
\ No newline at end of file
diff --git a/car-apps-common/res/values-af/strings.xml b/car-apps-common/res/values-af/strings.xml
new file mode 100644
index 0000000..0771610
--- /dev/null
+++ b/car-apps-common/res/values-af/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Vou knoppie in of uit"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Maak laai oop"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Maak laai toe"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Kenmerk is nie beskikbaar terwyl jy bestuur nie."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Rollees af"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Rollees op"</string>
+</resources>
diff --git a/car-apps-common/res/values-am/strings.xml b/car-apps-common/res/values-am/strings.xml
new file mode 100644
index 0000000..c3c5933
--- /dev/null
+++ b/car-apps-common/res/values-am/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"አዝራርን ዘርጋ/ሰብስብ"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"መሳቢያን ክፈት"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"መሳቢያን ዝጋ"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"እየነዱ ሳለ ባህሪ አይገኝም።"</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"ወደ ታች ይሸብልሉ"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"ወደ ላይ ይሸብልሉ"</string>
+</resources>
diff --git a/car-apps-common/res/values-ar/strings.xml b/car-apps-common/res/values-ar/strings.xml
new file mode 100644
index 0000000..c16969b
--- /dev/null
+++ b/car-apps-common/res/values-ar/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"زر التوسيع/التصغير"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"فتح الدُرج"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"إغلاق الدُرج"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"لا تتوفَّر الميزة أثناء القيادة."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"التمرير للأسفل"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"التمرير للأعلى"</string>
+</resources>
diff --git a/car-apps-common/res/values-as/strings.xml b/car-apps-common/res/values-as/strings.xml
new file mode 100644
index 0000000..bdb14e9
--- /dev/null
+++ b/car-apps-common/res/values-as/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"সম্প্ৰসাৰণ/সংকোচন বুটাম"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"ড্ৰৱাৰ খোলক"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"ড্ৰৱাৰ বন্ধ কৰক"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"গাড়ী চলোৱাৰ সময়ত এই সুবিধাটো উপলব্ধ নহয়।"</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"তললৈ স্ক্ৰল কৰক"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"ওপৰলৈ স্ক্ৰল কৰক"</string>
+</resources>
diff --git a/car-apps-common/res/values-az/strings.xml b/car-apps-common/res/values-az/strings.xml
new file mode 100644
index 0000000..7a705ca
--- /dev/null
+++ b/car-apps-common/res/values-az/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Düyməni genişləndirin/yığcamlaşdırın"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Çəkməcəni açın"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Çəkməcəni bağlayın"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Xüsusiyyət avtomobil idarə edərkən əlçatan deyil."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Aşağı sürüşdürün"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Yuxarı sürüşdürün"</string>
+</resources>
diff --git a/car-apps-common/res/values-b+sr+Latn/strings.xml b/car-apps-common/res/values-b+sr+Latn/strings.xml
new file mode 100644
index 0000000..4b64909
--- /dev/null
+++ b/car-apps-common/res/values-b+sr+Latn/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Dugme Proširi/skupi"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Otvori fioku"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Zatvori fioku"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Funkcija nije dostupna tokom vožnje."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Pomerite nadole"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Pomerite nagore"</string>
+</resources>
diff --git a/car-apps-common/res/values-be/strings.xml b/car-apps-common/res/values-be/strings.xml
new file mode 100644
index 0000000..8c0ae61
--- /dev/null
+++ b/car-apps-common/res/values-be/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Кнопка \"Разгарнуць/згарнуць\""</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Адкрыць высоўнае меню"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Закрыць высоўнае меню"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Функцыя недаступная, калі вы за рулём."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Прагартаць уніз"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Прагартаць уверх"</string>
+</resources>
diff --git a/car-apps-common/res/values-bg/strings.xml b/car-apps-common/res/values-bg/strings.xml
new file mode 100644
index 0000000..4c8dfad
--- /dev/null
+++ b/car-apps-common/res/values-bg/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Бутон за разгъване/свиване"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Отваряне на слоя"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Затваряне на слоя"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Функцията не е налице по време на шофиране."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Превъртане надолу"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Превъртане нагоре"</string>
+</resources>
diff --git a/car-apps-common/res/values-bn/strings.xml b/car-apps-common/res/values-bn/strings.xml
new file mode 100644
index 0000000..8c8f5eb
--- /dev/null
+++ b/car-apps-common/res/values-bn/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"বড় করা/আড়াল করার বোতাম"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"ড্রয়ার খুলুন"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"ড্রয়ার বন্ধ করুন"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"ড্রাইভ করার সময় এই ফিচার কাজ করবে না।"</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"নিচে স্ক্রল করুন"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"উপরে স্ক্রল করুন"</string>
+</resources>
diff --git a/car-apps-common/res/values-bs/strings.xml b/car-apps-common/res/values-bs/strings.xml
new file mode 100644
index 0000000..0d3bcc9
--- /dev/null
+++ b/car-apps-common/res/values-bs/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Dugme proširi/suzi"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Otvori ladicu"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Zatvori ladicu"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Funkcija nije dostupna tokom vožnje."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Klizni prema dolje"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Klizni prema gore"</string>
+</resources>
diff --git a/car-apps-common/res/values-ca/strings.xml b/car-apps-common/res/values-ca/strings.xml
new file mode 100644
index 0000000..df3b477
--- /dev/null
+++ b/car-apps-common/res/values-ca/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Botó per desplegar o replegar"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Obre el tauler"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Tanca el tauler"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Aquesta funció no està disponible mentre condueixes."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Desplaça cap avall"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Desplaça cap amunt"</string>
+</resources>
diff --git a/car-apps-common/res/values-cs/strings.xml b/car-apps-common/res/values-cs/strings.xml
new file mode 100644
index 0000000..6872e31
--- /dev/null
+++ b/car-apps-common/res/values-cs/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Tlačítko rozbalení/sbalení"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Otevřít vysouvací panel"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Zavřít vysouvací panel"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Funkce při řízení není dostupná."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Posunout dolů"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Posunout nahoru"</string>
+</resources>
diff --git a/car-apps-common/res/values-da/strings.xml b/car-apps-common/res/values-da/strings.xml
new file mode 100644
index 0000000..49b1021
--- /dev/null
+++ b/car-apps-common/res/values-da/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Knappen Udvid/skjul"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Åbn skuffen"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Luk skuffen"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Funktionen er ikke tilgængelig under kørsel."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Rul ned"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Rul op"</string>
+</resources>
diff --git a/car-apps-common/res/values-de/strings.xml b/car-apps-common/res/values-de/strings.xml
new file mode 100644
index 0000000..25cc654
--- /dev/null
+++ b/car-apps-common/res/values-de/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Schaltfläche zum Maximieren/Minimieren"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Leiste öffnen"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Leiste schließen"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Funktion während der Fahrt nicht verfügbar."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Nach unten scrollen"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Nach oben scrollen"</string>
+</resources>
diff --git a/car-apps-common/res/values-el/strings.xml b/car-apps-common/res/values-el/strings.xml
new file mode 100644
index 0000000..43bcbda
--- /dev/null
+++ b/car-apps-common/res/values-el/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Κουμπί ανάπτυξης/σύμπτυξης"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Άνοιγμα συρταριού"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Κλείσιμο συρταριού"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Η λειτουργία δεν διατίθεται κατά τη διάρκεια της οδήγησης."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Κύλιση προς τα κάτω"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Κύλιση προς τα επάνω"</string>
+</resources>
diff --git a/car-apps-common/res/values-en-rAU/strings.xml b/car-apps-common/res/values-en-rAU/strings.xml
new file mode 100644
index 0000000..691ae06
--- /dev/null
+++ b/car-apps-common/res/values-en-rAU/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Expand/collapse button"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Open drawer"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Close drawer"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Feature not available while driving."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Scroll down"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Scroll up"</string>
+</resources>
diff --git a/car-apps-common/res/values-en-rCA/strings.xml b/car-apps-common/res/values-en-rCA/strings.xml
new file mode 100644
index 0000000..691ae06
--- /dev/null
+++ b/car-apps-common/res/values-en-rCA/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Expand/collapse button"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Open drawer"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Close drawer"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Feature not available while driving."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Scroll down"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Scroll up"</string>
+</resources>
diff --git a/car-apps-common/res/values-en-rGB/strings.xml b/car-apps-common/res/values-en-rGB/strings.xml
new file mode 100644
index 0000000..691ae06
--- /dev/null
+++ b/car-apps-common/res/values-en-rGB/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Expand/collapse button"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Open drawer"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Close drawer"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Feature not available while driving."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Scroll down"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Scroll up"</string>
+</resources>
diff --git a/car-apps-common/res/values-en-rIN/strings.xml b/car-apps-common/res/values-en-rIN/strings.xml
new file mode 100644
index 0000000..691ae06
--- /dev/null
+++ b/car-apps-common/res/values-en-rIN/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Expand/collapse button"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Open drawer"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Close drawer"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Feature not available while driving."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Scroll down"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Scroll up"</string>
+</resources>
diff --git a/car-apps-common/res/values-en-rXC/strings.xml b/car-apps-common/res/values-en-rXC/strings.xml
new file mode 100644
index 0000000..d9b3382
--- /dev/null
+++ b/car-apps-common/res/values-en-rXC/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‏‎‏‎‏‏‏‏‎‏‏‏‎‏‏‏‏‎‎‎‎‏‏‏‎‏‎‎‎‏‎‎‎‎‏‏‎‏‏‏‏‏‏‏‏‏‏‎‎‏‎‎‎‏‏‎‎‎‏‏‎‎‏‎‎Expand/collapse button‎‏‎‎‏‎"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‏‎‏‎‎‏‎‏‎‎‏‎‎‏‎‎‎‏‏‎‎‎‏‎‏‎‎‏‎‏‎‏‎‏‏‎‏‏‏‎‏‏‏‎‎‎‎‎‎‎‎‎‏‎‎‎‎‎‏‏‎‏‎‎‎Open drawer‎‏‎‎‏‎"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‏‏‏‎‎‏‎‎‏‏‏‏‏‎‏‎‏‏‎‏‏‏‏‎‏‏‏‏‏‏‏‎‏‎‏‏‏‏‎‏‏‏‎‏‏‎‎‎‏‏‎‏‎‎‎‏‏‎‏‎‏‎‏‏‏‎Close drawer‎‏‎‎‏‎"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‎‏‏‏‏‏‏‏‎‎‏‏‏‎‏‎‎‏‏‎‎‎‏‎‎‏‎‏‏‎‎‏‎‎‎‎‎‏‎‏‎‏‏‎‏‏‏‎‎‏‎‏‏‏‏‏‎‏‏‎‏‎‏‎Feature not available while driving.‎‏‎‎‏‎"</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‏‏‏‏‏‎‏‏‏‏‏‎‏‎‎‎‎‏‎‎‎‎‏‎‏‎‏‏‎‎‏‎‎‏‎‏‏‎‎‎‏‎‏‎‎‏‎‏‏‎‎‎‎‎‎‏‏‏‏‏‎‎‎‏‎‎Scroll down‎‏‎‎‏‎"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‏‏‏‏‏‎‎‏‏‎‏‎‎‎‏‏‎‎‏‎‎‏‏‏‏‎‏‏‎‎‎‎‏‏‏‏‏‎‏‏‏‎‏‏‏‏‎‎‎‎‏‏‎‏‎‎‏‏‏‎‏‏‎‎‏‎Scroll up‎‏‎‎‏‎"</string>
+</resources>
diff --git a/car-apps-common/res/values-es-rUS/strings.xml b/car-apps-common/res/values-es-rUS/strings.xml
new file mode 100644
index 0000000..df2217f
--- /dev/null
+++ b/car-apps-common/res/values-es-rUS/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Botón Expandir/contraer"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Abrir panel lateral"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Cerrar panel lateral"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Esta función no está disponible mientras conduces."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Desplazarse hacia abajo"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Desplazarse hacia arriba"</string>
+</resources>
diff --git a/car-apps-common/res/values-es/strings.xml b/car-apps-common/res/values-es/strings.xml
new file mode 100644
index 0000000..23fcbc5
--- /dev/null
+++ b/car-apps-common/res/values-es/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Botón para mostrar u ocultar"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Abrir panel"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Cerrar panel"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Esta función no está disponible mientras conduces."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Desplazarse hacia abajo"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Desplazarse hacia arriba"</string>
+</resources>
diff --git a/car-apps-common/res/values-et/strings.xml b/car-apps-common/res/values-et/strings.xml
new file mode 100644
index 0000000..7475c1a
--- /dev/null
+++ b/car-apps-common/res/values-et/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Nupp Laienda/Ahenda"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Ava sahtel"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Sule sahtel"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Funktsioon pole sõidu ajal saadaval."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Keri alla"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Keri üles"</string>
+</resources>
diff --git a/car-apps-common/res/values-eu/strings.xml b/car-apps-common/res/values-eu/strings.xml
new file mode 100644
index 0000000..a974c40
--- /dev/null
+++ b/car-apps-common/res/values-eu/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Zabaltzeko/Tolesteko botoia"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Ireki panel lerrakorra"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Itxi panel lerrakorra"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Eginbide hau ezin da erabili gidatu bitartean."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Egin behera"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Egin gora"</string>
+</resources>
diff --git a/car-apps-common/res/values-fa/strings.xml b/car-apps-common/res/values-fa/strings.xml
new file mode 100644
index 0000000..5586b6d
--- /dev/null
+++ b/car-apps-common/res/values-fa/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"دکمه بزرگ کردن/کوچک کردن"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"باز کردن کشو"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"بستن کشو"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"هنگام رانندگی، این ویژگی در دسترس نیست."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"پیمایش به پایین"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"پیمایش به بالا"</string>
+</resources>
diff --git a/car-apps-common/res/values-fi/strings.xml b/car-apps-common/res/values-fi/strings.xml
new file mode 100644
index 0000000..baa420f
--- /dev/null
+++ b/car-apps-common/res/values-fi/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Laajennus- ja tiivistyspainike"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Avaa vetopaneeli"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Sulje vetopaneeli"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Ominaisuus ei ole käytettävissä ajon aikana."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Vieritä alas"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Vieritä ylös"</string>
+</resources>
diff --git a/car-apps-common/res/values-fr-rCA/strings.xml b/car-apps-common/res/values-fr-rCA/strings.xml
new file mode 100644
index 0000000..5876f75
--- /dev/null
+++ b/car-apps-common/res/values-fr-rCA/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Bouton Développer/Réduire"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Ouvrir le tiroir"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Fermer le tiroir"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Cette fonction n\'est pas accessible durant la conduite."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Faire défiler vers le bas"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Faire défiler vers le haut"</string>
+</resources>
diff --git a/car-apps-common/res/values-fr/strings.xml b/car-apps-common/res/values-fr/strings.xml
new file mode 100644
index 0000000..454c27d
--- /dev/null
+++ b/car-apps-common/res/values-fr/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Bouton Développer/Réduire"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Ouvrir le panneau"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Fermer le panneau"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Fonctionnalité non disponible lorsque vous conduisez."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Faire défiler l\'écran vers le bas"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Faire défiler l\'écran vers le haut"</string>
+</resources>
diff --git a/car-apps-common/res/values-gl/strings.xml b/car-apps-common/res/values-gl/strings.xml
new file mode 100644
index 0000000..bd2b8ae
--- /dev/null
+++ b/car-apps-common/res/values-gl/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Botón despregar/contraer"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Abrir panel"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Pecha panel"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Esta función non está dispoñible mentres conduces."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Desprazarse cara abaixo"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Desprazarse cara arriba"</string>
+</resources>
diff --git a/car-apps-common/res/values-gu/strings.xml b/car-apps-common/res/values-gu/strings.xml
new file mode 100644
index 0000000..ed142d2
--- /dev/null
+++ b/car-apps-common/res/values-gu/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"મોટું કરો/નાનું કરો બટન"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"ડ્રોઅર ખોલો"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"ડ્રોઅર બંધ કરો"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"ડ્રાઇવિંગ કરતી વખતે આ સુવિધા ઉપલબ્ધ રહેશે નહીં."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"નીચેની તરફ સ્ક્રોલ કરો"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"ઉપરની તરફ સ્ક્રોલ કરો"</string>
+</resources>
diff --git a/car-apps-common/res/values-hi/strings.xml b/car-apps-common/res/values-hi/strings.xml
new file mode 100644
index 0000000..d703af5
--- /dev/null
+++ b/car-apps-common/res/values-hi/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"बड़ा/छोटा करने वाला बटन"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"दराज खोलें"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"दराज बंद करें"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"गाड़ी चलाते समय इस सुविधा का इस्तेमाल नहीं किया जा सकता."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"नीचे स्क्रोल करें"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"ऊपर स्क्रोल करें"</string>
+</resources>
diff --git a/car-apps-common/res/values-hr/strings.xml b/car-apps-common/res/values-hr/strings.xml
new file mode 100644
index 0000000..d51f1da
--- /dev/null
+++ b/car-apps-common/res/values-hr/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Gumb za proširivanje/sažimanje"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Otvori ladicu"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Zatvori ladicu"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Značajka nije dostupna tijekom vožnje."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Pomakni prema dolje"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Pomakni prema gore"</string>
+</resources>
diff --git a/car-apps-common/res/values-hu/strings.xml b/car-apps-common/res/values-hu/strings.xml
new file mode 100644
index 0000000..072f171
--- /dev/null
+++ b/car-apps-common/res/values-hu/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Gomb kibontása/összecsukása"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Fiók megnyitása"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Fiók bezárása"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Vezetés közben nem áll rendelkezésre a funkció."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Görgetés lefelé"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Görgetés felfelé"</string>
+</resources>
diff --git a/car-apps-common/res/values-hy/strings.xml b/car-apps-common/res/values-hy/strings.xml
new file mode 100644
index 0000000..83ec434
--- /dev/null
+++ b/car-apps-common/res/values-hy/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"«Ծավալել/ծալել» կոճակ"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Բացել դարակը"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Փակել դարակը"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Վարելու ընթացքում գործառույթը հասանելի չէ:"</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Ոլորել վար"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Ոլորել վեր"</string>
+</resources>
diff --git a/car-apps-common/res/values-in/strings.xml b/car-apps-common/res/values-in/strings.xml
new file mode 100644
index 0000000..bf170e7
--- /dev/null
+++ b/car-apps-common/res/values-in/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Tombol luaskan/ciutkan"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Buka panel samping"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Tutup panel samping"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Fitur tidak tersedia saat mengemudi."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Scroll ke bawah"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Scroll ke atas"</string>
+</resources>
diff --git a/car-apps-common/res/values-is/strings.xml b/car-apps-common/res/values-is/strings.xml
new file mode 100644
index 0000000..2c4c07d
--- /dev/null
+++ b/car-apps-common/res/values-is/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Hnappur til að stækka/minnka"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Opna skúffu"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Loka skúffu"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Þessi eiginleiki er ekki í boði á meðan þú ekur."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Fletta niður"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Fletta upp"</string>
+</resources>
diff --git a/car-apps-common/res/values-it/strings.xml b/car-apps-common/res/values-it/strings.xml
new file mode 100644
index 0000000..37635fd
--- /dev/null
+++ b/car-apps-common/res/values-it/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Pulsante Espandi/Comprimi"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Apri riquadro a scomparsa"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Chiudi riquadro a scomparsa"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Funzione non disponibile durante la guida."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Scorri verso il basso"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Scorri verso l\'alto"</string>
+</resources>
diff --git a/car-apps-common/res/values-iw/strings.xml b/car-apps-common/res/values-iw/strings.xml
new file mode 100644
index 0000000..417b016
--- /dev/null
+++ b/car-apps-common/res/values-iw/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"לחצן הרחבה וכיווץ"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"פתיחת חלונית ההזזה"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"סגירת חלונית ההזזה"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"התכונה לא זמינה במהלך הנהיגה."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"גלילה למטה"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"גלילה למעלה"</string>
+</resources>
diff --git a/car-apps-common/res/values-ja/strings.xml b/car-apps-common/res/values-ja/strings.xml
new file mode 100644
index 0000000..6a7ace0
--- /dev/null
+++ b/car-apps-common/res/values-ja/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"展開 / 折りたたみボタン"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"ドロワーを開く"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"ドロワーを閉じる"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"この機能は運転中は利用できません。"</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"下にスクロール"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"上にスクロール"</string>
+</resources>
diff --git a/car-apps-common/res/values-ka/strings.xml b/car-apps-common/res/values-ka/strings.xml
new file mode 100644
index 0000000..d95190b
--- /dev/null
+++ b/car-apps-common/res/values-ka/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"გაშლის/ჩაკეცვის ღილაკი"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"უჯრის გახსნა"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"უჯრის დახურვა"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"ფუნქცია მიუწვდომელია მანქანის მართვისას."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"ქვემოთ გადაადგილება"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"ზემოთ გადაადგილება"</string>
+</resources>
diff --git a/car-apps-common/res/values-kk/strings.xml b/car-apps-common/res/values-kk/strings.xml
new file mode 100644
index 0000000..1366c3b
--- /dev/null
+++ b/car-apps-common/res/values-kk/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"\"Жаю/Жию\" түймесі"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Тартпаны ашу"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Тартпаны жабу"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Көлік жүргізу кезінде бұл функция жұмыс істемейді."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Төмен қарай айналдыру"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Жоғары қарай айналдыру"</string>
+</resources>
diff --git a/car-apps-common/res/values-km/strings.xml b/car-apps-common/res/values-km/strings.xml
new file mode 100644
index 0000000..4a695e0
--- /dev/null
+++ b/car-apps-common/res/values-km/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"ប៊ូតុង​ពង្រីក/បង្រួម"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"បើកថត"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"បិទថត"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"មិនអាច​ប្រើមុខងារ​នេះបានទេ ខណៈពេល​កំពុង​បើកបរ។"</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"រំកិលចុះក្រោម"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"រំកិល​​ឡើង​លើ"</string>
+</resources>
diff --git a/car-apps-common/res/values-kn/strings.xml b/car-apps-common/res/values-kn/strings.xml
new file mode 100644
index 0000000..f7bdb7f
--- /dev/null
+++ b/car-apps-common/res/values-kn/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"ವಿಸ್ತರಿಸಿ/ಕುಗ್ಗಿಸಿ ಬಟನ್"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"ಡ್ರಾಯರ್ ತೆರೆಯಿರಿ"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"ಡ್ರಾಯರ್ ಮುಚ್ಚಿರಿ"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"ಡ್ರೈವ್ ಮಾಡುವಾಗ ಈ ವೈಶಿಷ್ಟ್ಯ ಲಭ್ಯವಿಲ್ಲ."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"ಕೆಳಗೆ ಸ್ಕ್ರಾಲ್ ಮಾಡಿ"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"ಮೇಲೆ ಸ್ಕ್ರಾಲ್ ಮಾಡಿ"</string>
+</resources>
diff --git a/car-apps-common/res/values-ko/strings.xml b/car-apps-common/res/values-ko/strings.xml
new file mode 100644
index 0000000..526c776
--- /dev/null
+++ b/car-apps-common/res/values-ko/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"펼치기/접기 버튼"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"창 열기"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"창 닫기"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"운전 중 기능 사용 불가"</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"아래로 스크롤"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"위로 스크롤"</string>
+</resources>
diff --git a/car-apps-common/res/values-ky/strings.xml b/car-apps-common/res/values-ky/strings.xml
new file mode 100644
index 0000000..23ac2c0
--- /dev/null
+++ b/car-apps-common/res/values-ky/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Жайып көрсөтүү/жыйыштыруу баскычы"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Суурманы ачуу"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Суурманы жабуу"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Унаа айдаганда бул функция жеткиликтүү эмес."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Төмөн сыдыруу"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Жогору сыдыруу"</string>
+</resources>
diff --git a/car-apps-common/res/values-lo/strings.xml b/car-apps-common/res/values-lo/strings.xml
new file mode 100644
index 0000000..d52a414
--- /dev/null
+++ b/car-apps-common/res/values-lo/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"ປຸ່ມຫຍໍ້/ຂະຫຍາຍ"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"ເປີດລິ້ນ​ຊັກ"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"ປິດ​ລິ້ນ​ຊັກ"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"ຄຸນສົມບັດບໍ່ສາມາດໃຊ້ໄດ້ໃນເວລາຂັບລົດ."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"ເລື່ອນລົງ"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"ເລື່ອນຂຶ້ນ"</string>
+</resources>
diff --git a/car-apps-common/res/values-lt/strings.xml b/car-apps-common/res/values-lt/strings.xml
new file mode 100644
index 0000000..db4a28d
--- /dev/null
+++ b/car-apps-common/res/values-lt/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Mygtukas „Išskleisti / sutraukti“"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Atidaryti skydelį"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Uždaryti skydelį"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Funkcija nepasiekiama vairuojant."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Slinkti žemyn"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Slinkti aukštyn"</string>
+</resources>
diff --git a/car-apps-common/res/values-lv/strings.xml b/car-apps-common/res/values-lv/strings.xml
new file mode 100644
index 0000000..3b72539
--- /dev/null
+++ b/car-apps-common/res/values-lv/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Izvēršanas/sakļaušanas poga"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Atvērt atvilktni"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Aizvērt atvilktni"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Funkcija nav pieejama braukšanas laikā."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Ritināt uz leju"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Ritināt uz augšu"</string>
+</resources>
diff --git a/car-apps-common/res/values-mk/strings.xml b/car-apps-common/res/values-mk/strings.xml
new file mode 100644
index 0000000..b43a4d1
--- /dev/null
+++ b/car-apps-common/res/values-mk/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Копче за проширување/собирање"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Отвори ја фиоката"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Затвори ја фиоката"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Функцијата не е достапна при возење."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Оди надолу"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Оди нагоре"</string>
+</resources>
diff --git a/car-apps-common/res/values-ml/strings.xml b/car-apps-common/res/values-ml/strings.xml
new file mode 100644
index 0000000..6b6c309
--- /dev/null
+++ b/car-apps-common/res/values-ml/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"വികസിപ്പിക്കുക/ചുരുക്കുക ബട്ടൺ"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"വലിപ്പ് തുറക്കുക"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"വലിപ്പ് അടയ്ക്കുക"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"ഡ്രൈവ് ചെയ്യുമ്പോൾ ഫീച്ചർ ലഭ്യമല്ല."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"താഴോട്ട് സ്‌ക്രോൾ ചെയ്യുക"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"മുകളിലോട്ട് സ്‌ക്രോൾ ചെയ്യുക"</string>
+</resources>
diff --git a/car-apps-common/res/values-mn/strings.xml b/car-apps-common/res/values-mn/strings.xml
new file mode 100644
index 0000000..92a8dae
--- /dev/null
+++ b/car-apps-common/res/values-mn/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Дэлгэх/буулгах товчлуур"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Шургуулгыг нээх"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Шургуулгыг хаах"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Жолоо барьж байх үед онцлог боломжгүй."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Доош гүйлгэх"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Дээш гүйлгэх"</string>
+</resources>
diff --git a/car-apps-common/res/values-mr/strings.xml b/car-apps-common/res/values-mr/strings.xml
new file mode 100644
index 0000000..671b387
--- /dev/null
+++ b/car-apps-common/res/values-mr/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"बटण विस्‍तृत करा/कोलॅप्‍स करा"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"ड्रॉवर उघडा"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"ड्रॉवर बंद करा"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"ड्राइव्ह करताना वैशिष्ट्य उपलब्ध नाही."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"खाली स्क्रोल करा"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"वर स्क्रोल करा"</string>
+</resources>
diff --git a/car-apps-common/res/values-ms/strings.xml b/car-apps-common/res/values-ms/strings.xml
new file mode 100644
index 0000000..4a5c1e6
--- /dev/null
+++ b/car-apps-common/res/values-ms/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Butang kembangkan/runtuhkan"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Buka laci"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Tutup laci"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Ciri tidak tersedia semasa anda memandu."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Tatal ke bawah"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Tatal ke atas"</string>
+</resources>
diff --git a/car-apps-common/res/values-my/strings.xml b/car-apps-common/res/values-my/strings.xml
new file mode 100644
index 0000000..cf2fcf6
--- /dev/null
+++ b/car-apps-common/res/values-my/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"ချဲ့ရန်/လျှော့ပြရန် ခလုတ်"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"အံဆွဲ ဖွင့်ရန်"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"အံဆွဲ ပိတ်ရန်"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"ကားမောင်းနေစဉ် ဝန်ဆောင်မှု မရနိုင်ပါ။"</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"အောက်သို့ လှိမ့်ရန်"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"အပေါ်သို့ လှိမ့်ရန်"</string>
+</resources>
diff --git a/car-apps-common/res/values-nb/strings.xml b/car-apps-common/res/values-nb/strings.xml
new file mode 100644
index 0000000..0fb9039
--- /dev/null
+++ b/car-apps-common/res/values-nb/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Vis/skjul-knapp"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Åpne uttrekksmenyen"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Lukk uttrekksmenyen"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Funksjonen er ikke tilgjengelig når du kjører."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Rull ned"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Rull opp"</string>
+</resources>
diff --git a/car-apps-common/res/values-ne/strings.xml b/car-apps-common/res/values-ne/strings.xml
new file mode 100644
index 0000000..1599bc8
--- /dev/null
+++ b/car-apps-common/res/values-ne/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"विस्तृत/संक्षिप्त गर्ने बटन"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"ड्रअर खोल्नुहोस्"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"ड्रअर बन्द गर्नुहोस्"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"सवारी साधन चलाइरहेका बेला यो सुविधा उपलब्ध छैन।"</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"तल स्क्रोल गर्नुहोस्"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"माथितिर स्क्रोल गर्नुहोस्"</string>
+</resources>
diff --git a/car-apps-common/res/values-nl/strings.xml b/car-apps-common/res/values-nl/strings.xml
new file mode 100644
index 0000000..0c7f378
--- /dev/null
+++ b/car-apps-common/res/values-nl/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Knop voor uitvouwen/samenvouwen"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Lade openen"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Lade sluiten"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Functie niet beschikbaar tijdens het rijden."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Omlaag scrollen"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Omhoog scrollen"</string>
+</resources>
diff --git a/car-apps-common/res/values-or/strings.xml b/car-apps-common/res/values-or/strings.xml
new file mode 100644
index 0000000..b921f45
--- /dev/null
+++ b/car-apps-common/res/values-or/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"ବିସ୍ତାର/ସଂକୋଚନ ବଟନ୍"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"ଡ୍ରୟର୍ ଖୋଲନ୍ତୁ"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"ଡ୍ରୟର୍ ବନ୍ଦ କରନ୍ତୁ"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"ଗାଡ଼ି ଚଲାଇବା ସମୟରେ ଫିଚର୍ ଉପଲବ୍ଧ ହେବ ନାହିଁ।"</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"ତଳକୁ ସ୍କ୍ରୋଲ୍ କରନ୍ତୁ"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"ଉପରକୁ ସ୍କ୍ରୋଲ୍ କରନ୍ତୁ"</string>
+</resources>
diff --git a/car-apps-common/res/values-pa/strings.xml b/car-apps-common/res/values-pa/strings.xml
new file mode 100644
index 0000000..f6c1657
--- /dev/null
+++ b/car-apps-common/res/values-pa/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"ਵਿਸਤਾਰ ਕਰੋ/ਸਮੇਟੋ ਬਟਨ"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"ਦਰਾਜ਼ ਖੋਲ੍ਹੋ"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"ਦਰਾਜ਼ ਬੰਦ ਕਰੋ"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"ਗੱਡੀ ਚਲਾਉਣ ਵੇਲੇ ਵਿਸ਼ੇਸ਼ਤਾ ਉਪਲਬਧ ਨਹੀਂ ਹੈ।"</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"ਹੇਠਾਂ ਵੱਲ ਸਕ੍ਰੋਲ ਕਰੋ"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"ਉੱਪਰ ਵੱਲ ਸਕ੍ਰੋਲ ਕਰੋ"</string>
+</resources>
diff --git a/car-apps-common/res/values-pl/strings.xml b/car-apps-common/res/values-pl/strings.xml
new file mode 100644
index 0000000..2ad6309
--- /dev/null
+++ b/car-apps-common/res/values-pl/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Przycisk zwijania/rozwijania"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Otwórz panel"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Zamknij panel"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Funkcja niedostępna podczas jazdy."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Przewiń w dół"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Przewiń w górę"</string>
+</resources>
diff --git a/car-apps-common/res/values-pt-rPT/strings.xml b/car-apps-common/res/values-pt-rPT/strings.xml
new file mode 100644
index 0000000..0d461e3
--- /dev/null
+++ b/car-apps-common/res/values-pt-rPT/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Botão Expandir/reduzir"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Abrir gaveta"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Fechar gaveta"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Funcionalidade não disponível durante a condução."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Deslocar para baixo"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Deslocar para cima"</string>
+</resources>
diff --git a/car-apps-common/res/values-pt/strings.xml b/car-apps-common/res/values-pt/strings.xml
new file mode 100644
index 0000000..118bf92
--- /dev/null
+++ b/car-apps-common/res/values-pt/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Botão \"Expandir/Recolher\""</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Abrir gaveta"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Fechar gaveta"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Recurso não disponível enquanto você dirige."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Rolar para baixo"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Rolar para cima"</string>
+</resources>
diff --git a/car-apps-common/res/values-ro/strings.xml b/car-apps-common/res/values-ro/strings.xml
new file mode 100644
index 0000000..6a78b9c
--- /dev/null
+++ b/car-apps-common/res/values-ro/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Butonul de extindere/restrângere"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Deschideți panoul"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Închideți panoul"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Funcția nu este disponibilă când conduceți."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Derulați în jos"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Derulați în sus"</string>
+</resources>
diff --git a/car-apps-common/res/values-ru/strings.xml b/car-apps-common/res/values-ru/strings.xml
new file mode 100644
index 0000000..11e0f3e
--- /dev/null
+++ b/car-apps-common/res/values-ru/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Кнопка \"Развернуть/свернуть\""</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Открыть панель"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Закрыть панель"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Эта функция недоступна, когда вы за рулем."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Прокрутить вниз"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Прокрутить вверх"</string>
+</resources>
diff --git a/car-apps-common/res/values-si/strings.xml b/car-apps-common/res/values-si/strings.xml
new file mode 100644
index 0000000..8d2f5d6
--- /dev/null
+++ b/car-apps-common/res/values-si/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"දිග හැරීමේ/හැකිළීමේ බොත්තම"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"ලාච්චුව විවෘත කරන්න"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"ලාච්චුව වසන්න"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"විශේෂාංගය රිය පැදවීමේ දී නොමැත."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"පහළට අනුචලනය කරන්න"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"ඉහළට අනුචලනය කරන්න"</string>
+</resources>
diff --git a/car-apps-common/res/values-sk/strings.xml b/car-apps-common/res/values-sk/strings.xml
new file mode 100644
index 0000000..3159fb6
--- /dev/null
+++ b/car-apps-common/res/values-sk/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Tlačidlo rozbalenia/zbalenia"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Otvoriť vysúvací panel"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Zavrieť vysúvací panel"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Funkcia nie je k dispozícii počas jazdy."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Posunúť nadol"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Posunúť nahor"</string>
+</resources>
diff --git a/car-apps-common/res/values-sl/strings.xml b/car-apps-common/res/values-sl/strings.xml
new file mode 100644
index 0000000..14457c2
--- /dev/null
+++ b/car-apps-common/res/values-sl/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Gumb za razširitev/strnitev"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Odpri predal"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Zapri predal"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Funkcija med vožnjo ni na voljo."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Pomik navzdol"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Pomik navzgor"</string>
+</resources>
diff --git a/car-apps-common/res/values-sq/strings.xml b/car-apps-common/res/values-sq/strings.xml
new file mode 100644
index 0000000..4b980c3
--- /dev/null
+++ b/car-apps-common/res/values-sq/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Butoni i zgjerimit/palosjes"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Hap sirtarin"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Mbyll sirtarin"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Funksioni nuk ofrohet gjatë drejtimit të makinës."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Lëviz poshtë"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Lëviz lart"</string>
+</resources>
diff --git a/car-apps-common/res/values-sr/strings.xml b/car-apps-common/res/values-sr/strings.xml
new file mode 100644
index 0000000..60b1615
--- /dev/null
+++ b/car-apps-common/res/values-sr/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Дугме Прошири/скупи"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Отвори фиоку"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Затвори фиоку"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Функција није доступна током вожње."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Померите надоле"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Померите нагоре"</string>
+</resources>
diff --git a/car-apps-common/res/values-sv/strings.xml b/car-apps-common/res/values-sv/strings.xml
new file mode 100644
index 0000000..84d19f1
--- /dev/null
+++ b/car-apps-common/res/values-sv/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Knappen Utöka/komprimera"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Öppna utdragbar panel"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Stäng utdragbar panel"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Funktionen är inte tillgänglig när du kör."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Skrolla nedåt"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Skrolla uppåt"</string>
+</resources>
diff --git a/car-apps-common/res/values-sw/strings.xml b/car-apps-common/res/values-sw/strings.xml
new file mode 100644
index 0000000..04ccada
--- /dev/null
+++ b/car-apps-common/res/values-sw/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Kitufe cha kupanua/kukunja"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Fungua droo"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Funga droo"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Kipengele hakipatikani unapoendesha gari."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Sogeza chini"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Sogeza juu"</string>
+</resources>
diff --git a/car-apps-common/res/values-ta/strings.xml b/car-apps-common/res/values-ta/strings.xml
new file mode 100644
index 0000000..c88f072
--- /dev/null
+++ b/car-apps-common/res/values-ta/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"விரிவாக்குவதற்கான/சுருக்குவதற்கான பட்டன்"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"டிராயரைத் திற"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"டிராயரை மூடுக"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"வாகனம் ஓட்டும்போது இந்த அம்சத்தைப் பயன்படுத்த இயலாது."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"கீழே நகர்த்துவதற்கான பட்டன்"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"மேலே நகர்த்துவதற்கான பட்டன்"</string>
+</resources>
diff --git a/car-apps-common/res/values-te/strings.xml b/car-apps-common/res/values-te/strings.xml
new file mode 100644
index 0000000..b2fce0a
--- /dev/null
+++ b/car-apps-common/res/values-te/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"విస్తరించు/కుదించు బటన్"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"డ్రాయర్‌ని తెరవండి"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"డ్రాయర్‌ను మూసివేయండి"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"డ్రైవింగ్ చేస్తున్నప్పుడు ఈ ఫీచర్ అందుబాటులో ఉండదు."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"కిందకు స్క్రోల్ చేయి"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"పైకి స్క్రోల్ చేయి"</string>
+</resources>
diff --git a/car-apps-common/res/values-th/strings.xml b/car-apps-common/res/values-th/strings.xml
new file mode 100644
index 0000000..93a7943
--- /dev/null
+++ b/car-apps-common/res/values-th/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"ปุ่มขยาย/ยุบ"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"เปิดลิ้นชัก"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"ปิดลิ้นชัก"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"ฟีเจอร์ไม่พร้อมใช้งานขณะขับรถ"</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"เลื่อนลง"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"เลื่อนขึ้น"</string>
+</resources>
diff --git a/car-apps-common/res/values-tl/strings.xml b/car-apps-common/res/values-tl/strings.xml
new file mode 100644
index 0000000..ef72afb
--- /dev/null
+++ b/car-apps-common/res/values-tl/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Button na palawakin/i-collapse"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Buksan ang drawer"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Isara ang drawer"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Hindi available ang feature habang nagmamaneho."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Mag-scroll pababa"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Mag-scroll pataas"</string>
+</resources>
diff --git a/car-apps-common/res/values-tr/strings.xml b/car-apps-common/res/values-tr/strings.xml
new file mode 100644
index 0000000..db95a8b
--- /dev/null
+++ b/car-apps-common/res/values-tr/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Genişlet/daralt düğmesi"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Çekmeceyi aç"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Çekmeceyi kapat"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Sürüş sırasında bu özellik kullanılamaz."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Aşağı kaydır"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Yukarı kaydır"</string>
+</resources>
diff --git a/car-apps-common/res/values-uk/strings.xml b/car-apps-common/res/values-uk/strings.xml
new file mode 100644
index 0000000..879da02
--- /dev/null
+++ b/car-apps-common/res/values-uk/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Кнопка \"Розгорнути\" або \"Згорнути\""</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Відкрити висувну панель"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Закрити висувну панель"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Функція недоступна під час руху автомобіля."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Прокрутити вниз"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Прокрутити вгору"</string>
+</resources>
diff --git a/car-apps-common/res/values-ur/strings.xml b/car-apps-common/res/values-ur/strings.xml
new file mode 100644
index 0000000..a9ab004
--- /dev/null
+++ b/car-apps-common/res/values-ur/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"پھیلائیں/سکیڑیں بٹن"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"دراز کھولیں"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"دراز بند کریں"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"ڈرائیونگ کے دوران یہ خصوصیت دستیاب نہیں ہے۔"</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"نیچے اسکرول کریں"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"اوپر اسکرول کریں"</string>
+</resources>
diff --git a/car-apps-common/res/values-uz/strings.xml b/car-apps-common/res/values-uz/strings.xml
new file mode 100644
index 0000000..65d2811
--- /dev/null
+++ b/car-apps-common/res/values-uz/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Yoyish/yigʻish tugmasi"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Panelni ochish"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Panelni yopish"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Avtomobilda harakatlanayotganda bu funksiya ishlamaydi."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Pastga tushish"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Tepaga chiqish"</string>
+</resources>
diff --git a/car-apps-common/res/values-vi/strings.xml b/car-apps-common/res/values-vi/strings.xml
new file mode 100644
index 0000000..044b905
--- /dev/null
+++ b/car-apps-common/res/values-vi/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Nút mở rộng/thu gọn"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Mở ngăn"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Đóng ngăn"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Bạn không sử dụng được tính năng này khi đang lái xe."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Cuộn xuống"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Cuộn lên"</string>
+</resources>
diff --git a/car-apps-common/res/values-zh-rCN/strings.xml b/car-apps-common/res/values-zh-rCN/strings.xml
new file mode 100644
index 0000000..899f786
--- /dev/null
+++ b/car-apps-common/res/values-zh-rCN/strings.xml
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for control_bar_expand_collapse_button (3420351169078117938) -->
+    <skip />
+    <string name="car_drawer_open" msgid="2676372472514742324">"打开抽屉式导航栏"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"关闭抽屉式导航栏"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"驾车时无法使用此功能。"</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"向下滚动"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"向上滚动"</string>
+</resources>
diff --git a/car-apps-common/res/values-zh-rHK/strings.xml b/car-apps-common/res/values-zh-rHK/strings.xml
new file mode 100644
index 0000000..2442206
--- /dev/null
+++ b/car-apps-common/res/values-zh-rHK/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"展開/收合按鈕"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"開啟導覽列"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"關閉導覽列"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"無法在駕駛時使用此功能。"</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"向下捲動"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"向上捲動"</string>
+</resources>
diff --git a/car-apps-common/res/values-zh-rTW/strings.xml b/car-apps-common/res/values-zh-rTW/strings.xml
new file mode 100644
index 0000000..cc45ad1
--- /dev/null
+++ b/car-apps-common/res/values-zh-rTW/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"展開/收合按鈕"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"開啟導覽匣"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"關閉導覽匣"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"開車時無法使用這項功能。"</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"向下捲動"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"向上捲動"</string>
+</resources>
diff --git a/car-apps-common/res/values-zu/strings.xml b/car-apps-common/res/values-zu/strings.xml
new file mode 100644
index 0000000..6f616b1
--- /dev/null
+++ b/car-apps-common/res/values-zu/strings.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="control_bar_expand_collapse_button" msgid="3420351169078117938">"Inkinobho yokunweba/ukugoqa"</string>
+    <string name="car_drawer_open" msgid="2676372472514742324">"Vula ikhabethe"</string>
+    <string name="car_drawer_close" msgid="5329374630462464855">"Vala ikhabethe"</string>
+    <string name="restricted_while_driving" msgid="2278031053760704437">"Isici asitholakali ngenkathi ushayela."</string>
+    <string name="scroll_bar_page_down_button" msgid="8633547153186948066">"Skrolela phansi"</string>
+    <string name="scroll_bar_page_up_button" msgid="8306413844913744345">"Skrolela phezulu"</string>
+</resources>
diff --git a/car-assist-client-lib/Android.bp b/car-assist-client-lib/Android.bp
new file mode 100644
index 0000000..8fe7b32
--- /dev/null
+++ b/car-assist-client-lib/Android.bp
@@ -0,0 +1,33 @@
+//
+// 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.
+//
+
+android_library {
+    name: "car-assist-client-lib",
+
+    srcs: ["src/**/*.java"],
+
+    resource_dirs: ["res"],
+
+    optimize: {
+        enabled: false,
+    },
+
+    static_libs: [
+        "androidx.legacy_legacy-support-v4",
+        "car-assist-lib",
+    ],
+
+}
diff --git a/car-assist-client-lib/Android.mk b/car-assist-client-lib/Android.mk
deleted file mode 100644
index ae687ac..0000000
--- a/car-assist-client-lib/Android.mk
+++ /dev/null
@@ -1,45 +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.
-#
-
-LOCAL_PATH:= $(call my-dir)
-
-include $(CLEAR_VARS)
-
-LOCAL_SRC_FILES := $(call all-java-files-under, src)
-
-LOCAL_RESOURCE_DIR := $(LOCAL_PATH)/res
-
-LOCAL_MODULE := car-assist-client-lib
-
-LOCAL_MODULE_TAGS := optional
-
-LOCAL_PRIVILEGED_MODULE := true
-
-LOCAL_PROGUARD_ENABLED := disabled
-
-LOCAL_USE_AAPT2 := true
-
-LOCAL_STATIC_ANDROID_LIBRARIES += \
-    androidx.legacy_legacy-support-v4 \
-
-LOCAL_STATIC_JAVA_LIBRARIES += \
-    car-assist-lib \
-
-include $(BUILD_STATIC_JAVA_LIBRARY)
-
-ifeq (,$(ONE_SHOT_MAKEFILE))
-    include $(call all-makefiles-under,$(LOCAL_PATH))
-endif
diff --git a/car-assist-client-lib/res/values-af/strings.xml b/car-assist-client-lib/res/values-af/strings.xml
new file mode 100644
index 0000000..d6e54fe
--- /dev/null
+++ b/car-assist-client-lib/res/values-af/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Kon nie handeling deur Assistent versoek nie!"</string>
+    <string name="says" msgid="8575666015622916107">"sê"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-am/strings.xml b/car-assist-client-lib/res/values-am/strings.xml
new file mode 100644
index 0000000..2f0855b
--- /dev/null
+++ b/car-assist-client-lib/res/values-am/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"ከረዳት እርምጃ መጠየቅ አልተቻለም!"</string>
+    <string name="says" msgid="8575666015622916107">"እንዲህ ይላሉ"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-ar/strings.xml b/car-assist-client-lib/res/values-ar/strings.xml
new file mode 100644
index 0000000..8252183
--- /dev/null
+++ b/car-assist-client-lib/res/values-ar/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"تعذَّر طلَب إجراء من \"مساعد Google\"."</string>
+    <string name="says" msgid="8575666015622916107">"يقول"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-as/strings.xml b/car-assist-client-lib/res/values-as/strings.xml
new file mode 100644
index 0000000..eec6ebd
--- /dev/null
+++ b/car-assist-client-lib/res/values-as/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Assistantএ কামটো কৰিব নোৱাৰিলে!"</string>
+    <string name="says" msgid="8575666015622916107">"এ কৈছে"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-az/strings.xml b/car-assist-client-lib/res/values-az/strings.xml
new file mode 100644
index 0000000..386d253
--- /dev/null
+++ b/car-assist-client-lib/res/values-az/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Assistentdən əməliyyat sorğulamaq mümkün olmadı!"</string>
+    <string name="says" msgid="8575666015622916107">"deyir"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-b+sr+Latn/strings.xml b/car-assist-client-lib/res/values-b+sr+Latn/strings.xml
new file mode 100644
index 0000000..eaa8a69
--- /dev/null
+++ b/car-assist-client-lib/res/values-b+sr+Latn/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Slanje zahteva za radnju Pomoćnika nije uspelo!"</string>
+    <string name="says" msgid="8575666015622916107">"kaže"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-be/strings.xml b/car-assist-client-lib/res/values-be/strings.xml
new file mode 100644
index 0000000..a35d999
--- /dev/null
+++ b/car-assist-client-lib/res/values-be/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Не ўдалося папрасіць Памочніка выканаць дзеянне."</string>
+    <string name="says" msgid="8575666015622916107">"гаворыць"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-bg/strings.xml b/car-assist-client-lib/res/values-bg/strings.xml
new file mode 100644
index 0000000..26f63a4
--- /dev/null
+++ b/car-assist-client-lib/res/values-bg/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Не можа да се заяви действие от Асистент!"</string>
+    <string name="says" msgid="8575666015622916107">"казва"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-bn/strings.xml b/car-assist-client-lib/res/values-bn/strings.xml
new file mode 100644
index 0000000..d9ccd59
--- /dev/null
+++ b/car-assist-client-lib/res/values-bn/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"নির্দেশ অনুসারে অ্যাসিস্ট্যান্ট কাজ করতে পারেনি!"</string>
+    <string name="says" msgid="8575666015622916107">"বলেছেন"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-bs/strings.xml b/car-assist-client-lib/res/values-bs/strings.xml
new file mode 100644
index 0000000..8f87241
--- /dev/null
+++ b/car-assist-client-lib/res/values-bs/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Nije zatražena akcija Asistenta!"</string>
+    <string name="says" msgid="8575666015622916107">"kaže"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-ca/strings.xml b/car-assist-client-lib/res/values-ca/strings.xml
new file mode 100644
index 0000000..78437cb
--- /dev/null
+++ b/car-assist-client-lib/res/values-ca/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"No s\'ha pogut sol·licitar l\'acció a l\'Assistent."</string>
+    <string name="says" msgid="8575666015622916107">"diu"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-cs/strings.xml b/car-assist-client-lib/res/values-cs/strings.xml
new file mode 100644
index 0000000..8f54a84
--- /dev/null
+++ b/car-assist-client-lib/res/values-cs/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Nebylo možné požádat Asistenta o akci."</string>
+    <string name="says" msgid="8575666015622916107">"říká"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-da/strings.xml b/car-assist-client-lib/res/values-da/strings.xml
new file mode 100644
index 0000000..38dc862
--- /dev/null
+++ b/car-assist-client-lib/res/values-da/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Handlingen kunne ikke håndteres af Assistent."</string>
+    <string name="says" msgid="8575666015622916107">"siger"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-de/strings.xml b/car-assist-client-lib/res/values-de/strings.xml
new file mode 100644
index 0000000..8f553cb
--- /dev/null
+++ b/car-assist-client-lib/res/values-de/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Aktion konnte nicht vom Assistant angefordert werden."</string>
+    <string name="says" msgid="8575666015622916107">"sagt"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-el/strings.xml b/car-assist-client-lib/res/values-el/strings.xml
new file mode 100644
index 0000000..9bdc6ee
--- /dev/null
+++ b/car-assist-client-lib/res/values-el/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Δεν ήταν δυνατό το αίτημα για ενέργεια στον Βοηθό!"</string>
+    <string name="says" msgid="8575666015622916107">"λέει"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-en-rAU/strings.xml b/car-assist-client-lib/res/values-en-rAU/strings.xml
new file mode 100644
index 0000000..2f5a3b7
--- /dev/null
+++ b/car-assist-client-lib/res/values-en-rAU/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Could not request action from Assistant!"</string>
+    <string name="says" msgid="8575666015622916107">"says"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-en-rCA/strings.xml b/car-assist-client-lib/res/values-en-rCA/strings.xml
new file mode 100644
index 0000000..2f5a3b7
--- /dev/null
+++ b/car-assist-client-lib/res/values-en-rCA/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Could not request action from Assistant!"</string>
+    <string name="says" msgid="8575666015622916107">"says"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-en-rGB/strings.xml b/car-assist-client-lib/res/values-en-rGB/strings.xml
new file mode 100644
index 0000000..2f5a3b7
--- /dev/null
+++ b/car-assist-client-lib/res/values-en-rGB/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Could not request action from Assistant!"</string>
+    <string name="says" msgid="8575666015622916107">"says"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-en-rIN/strings.xml b/car-assist-client-lib/res/values-en-rIN/strings.xml
new file mode 100644
index 0000000..2f5a3b7
--- /dev/null
+++ b/car-assist-client-lib/res/values-en-rIN/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Could not request action from Assistant!"</string>
+    <string name="says" msgid="8575666015622916107">"says"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-en-rXC/strings.xml b/car-assist-client-lib/res/values-en-rXC/strings.xml
new file mode 100644
index 0000000..d6611c0
--- /dev/null
+++ b/car-assist-client-lib/res/values-en-rXC/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‏‎‏‎‏‏‎‏‎‎‎‏‏‎‏‎‏‏‎‏‎‏‏‎‏‏‏‏‏‏‏‎‎‎‏‎‎‎‎‏‏‎‏‏‎‎‎‎‎‏‏‏‎‏‎‎‏‎‎‎‎‎‏‎‎Could not request action from Assistant!‎‏‎‎‏‎"</string>
+    <string name="says" msgid="8575666015622916107">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‏‏‏‏‏‎‏‏‏‎‎‎‎‎‎‏‎‏‏‏‎‎‎‏‎‏‏‎‎‏‏‏‎‎‎‏‎‏‏‎‏‏‎‎‏‎‏‏‏‏‏‏‎‏‎‎‎‎‎‎‎‏‎‏‏‎says‎‏‎‎‏‎"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-es-rUS/strings.xml b/car-assist-client-lib/res/values-es-rUS/strings.xml
new file mode 100644
index 0000000..307e7ec
--- /dev/null
+++ b/car-assist-client-lib/res/values-es-rUS/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"No se pudo solicitar la acción del Asistente"</string>
+    <string name="says" msgid="8575666015622916107">"dice"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-es/strings.xml b/car-assist-client-lib/res/values-es/strings.xml
new file mode 100644
index 0000000..e4e7e97
--- /dev/null
+++ b/car-assist-client-lib/res/values-es/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"No se ha podido solicitar la acción al Asistente."</string>
+    <string name="says" msgid="8575666015622916107">"dice"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-et/strings.xml b/car-assist-client-lib/res/values-et/strings.xml
new file mode 100644
index 0000000..91363e6
--- /dev/null
+++ b/car-assist-client-lib/res/values-et/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Assistendilt ei õnnestunud toimingut taotleda."</string>
+    <string name="says" msgid="8575666015622916107">"ütleb"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-eu/strings.xml b/car-assist-client-lib/res/values-eu/strings.xml
new file mode 100644
index 0000000..0bc404a
--- /dev/null
+++ b/car-assist-client-lib/res/values-eu/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Ezin izan da eskatu Laguntzailea eginbidearen ekintza!"</string>
+    <string name="says" msgid="8575666015622916107">"kontaktuak hau dio:"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-fa/strings.xml b/car-assist-client-lib/res/values-fa/strings.xml
new file mode 100644
index 0000000..00c7f18
--- /dev/null
+++ b/car-assist-client-lib/res/values-fa/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"نمی‌توانید از «دستیار» بخواهید کاری انجام دهد!"</string>
+    <string name="says" msgid="8575666015622916107">"می‌گوید"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-fi/strings.xml b/car-assist-client-lib/res/values-fi/strings.xml
new file mode 100644
index 0000000..613428a
--- /dev/null
+++ b/car-assist-client-lib/res/values-fi/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Toiminnon pyytäminen Assistantilta epäonnistui."</string>
+    <string name="says" msgid="8575666015622916107">"sanoo"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-fr-rCA/strings.xml b/car-assist-client-lib/res/values-fr-rCA/strings.xml
new file mode 100644
index 0000000..5791a4b
--- /dev/null
+++ b/car-assist-client-lib/res/values-fr-rCA/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Impossible de demander à l\'Assistant Google d\'effectuer une action!"</string>
+    <string name="says" msgid="8575666015622916107">"dit"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-fr/strings.xml b/car-assist-client-lib/res/values-fr/strings.xml
new file mode 100644
index 0000000..7004545
--- /dev/null
+++ b/car-assist-client-lib/res/values-fr/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Impossible de demander à l\'Assistant d\'effectuer cette action."</string>
+    <string name="says" msgid="8575666015622916107">"dit"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-gl/strings.xml b/car-assist-client-lib/res/values-gl/strings.xml
new file mode 100644
index 0000000..baec894
--- /dev/null
+++ b/car-assist-client-lib/res/values-gl/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Non se puido solicitar a acción ao Asistente."</string>
+    <string name="says" msgid="8575666015622916107">"di"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-gu/strings.xml b/car-assist-client-lib/res/values-gu/strings.xml
new file mode 100644
index 0000000..63e313c
--- /dev/null
+++ b/car-assist-client-lib/res/values-gu/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"આસિસ્ટંટને ક્રિયાની વિનંતી કરી શક્યાં નથી!"</string>
+    <string name="says" msgid="8575666015622916107">"કહે છે કે"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-hi/strings.xml b/car-assist-client-lib/res/values-hi/strings.xml
new file mode 100644
index 0000000..ba7afeb
--- /dev/null
+++ b/car-assist-client-lib/res/values-hi/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Assistant से कार्रवाई का अनुरोध नहीं किया जा सका!"</string>
+    <string name="says" msgid="8575666015622916107">"कहा है कि"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-hr/strings.xml b/car-assist-client-lib/res/values-hr/strings.xml
new file mode 100644
index 0000000..2da146b
--- /dev/null
+++ b/car-assist-client-lib/res/values-hr/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Nije bilo moguće zatražiti radnju od Asisitenta!"</string>
+    <string name="says" msgid="8575666015622916107">"kaže"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-hu/strings.xml b/car-assist-client-lib/res/values-hu/strings.xml
new file mode 100644
index 0000000..faa43e0
--- /dev/null
+++ b/car-assist-client-lib/res/values-hu/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Nem sikerült a Segéd-művelet kérése!"</string>
+    <string name="says" msgid="8575666015622916107">"azt mondja, hogy"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-hy/strings.xml b/car-assist-client-lib/res/values-hy/strings.xml
new file mode 100644
index 0000000..219b14b
--- /dev/null
+++ b/car-assist-client-lib/res/values-hy/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Չհաջողվեց Օգնականին խնդրել գործողություն կատարել"</string>
+    <string name="says" msgid="8575666015622916107">"օգտատերն ասում է."</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-in/strings.xml b/car-assist-client-lib/res/values-in/strings.xml
new file mode 100644
index 0000000..cedc390
--- /dev/null
+++ b/car-assist-client-lib/res/values-in/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Tidak dapat meminta tindakan dari Asisten!"</string>
+    <string name="says" msgid="8575666015622916107">"mengatakan"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-is/strings.xml b/car-assist-client-lib/res/values-is/strings.xml
new file mode 100644
index 0000000..1162c77
--- /dev/null
+++ b/car-assist-client-lib/res/values-is/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Ekki tókst að biðja hjálparann um aðgerð!"</string>
+    <string name="says" msgid="8575666015622916107">"segir"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-it/strings.xml b/car-assist-client-lib/res/values-it/strings.xml
new file mode 100644
index 0000000..4bac32b
--- /dev/null
+++ b/car-assist-client-lib/res/values-it/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Impossibile richiedere l\'azione all\'assistente"</string>
+    <string name="says" msgid="8575666015622916107">"dice"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-iw/strings.xml b/car-assist-client-lib/res/values-iw/strings.xml
new file mode 100644
index 0000000..510432d
--- /dev/null
+++ b/car-assist-client-lib/res/values-iw/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"לא ניתן לבקש מה-Assistant לבצע פעולה!"</string>
+    <string name="says" msgid="8575666015622916107">"רוצה להודיע כי"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-ja/strings.xml b/car-assist-client-lib/res/values-ja/strings.xml
new file mode 100644
index 0000000..2065208
--- /dev/null
+++ b/car-assist-client-lib/res/values-ja/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"アシスタント アクションをリクエストできませんでした"</string>
+    <string name="says" msgid="8575666015622916107">"さんからのメッセージです"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-ka/strings.xml b/car-assist-client-lib/res/values-ka/strings.xml
new file mode 100644
index 0000000..8076df9
--- /dev/null
+++ b/car-assist-client-lib/res/values-ka/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"ასისტენტისგან ქმედების მოთხოვნა ვერ მოხერხდა"</string>
+    <string name="says" msgid="8575666015622916107">"ამბობს"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-kk/strings.xml b/car-assist-client-lib/res/values-kk/strings.xml
new file mode 100644
index 0000000..b96f97f
--- /dev/null
+++ b/car-assist-client-lib/res/values-kk/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Assistant әрекетін сұрау мүмкін болмады."</string>
+    <string name="says" msgid="8575666015622916107">"былай дейді:"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-km/strings.xml b/car-assist-client-lib/res/values-km/strings.xml
new file mode 100644
index 0000000..64d1004
--- /dev/null
+++ b/car-assist-client-lib/res/values-km/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"មិនអាចស្នើសុំ​សកម្មភាពពី​ជំនួយការបានទេ!"</string>
+    <string name="says" msgid="8575666015622916107">"និយាយថា"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-kn/strings.xml b/car-assist-client-lib/res/values-kn/strings.xml
new file mode 100644
index 0000000..187a13a
--- /dev/null
+++ b/car-assist-client-lib/res/values-kn/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"ಅಸಿಸ್ಟೆಂಟ್‌ನಿಂದ ಕ್ರಿಯೆಗಾಗಿ ವಿನಂತಿಸಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ!"</string>
+    <string name="says" msgid="8575666015622916107">"ಹೇಳುತ್ತಾರೆ"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-ko/strings.xml b/car-assist-client-lib/res/values-ko/strings.xml
new file mode 100644
index 0000000..e0bc7e8
--- /dev/null
+++ b/car-assist-client-lib/res/values-ko/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"어시스턴트에서 요청 작업을 찾을 수 없습니다."</string>
+    <string name="says" msgid="8575666015622916107">"님의 메시지:"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-ky/strings.xml b/car-assist-client-lib/res/values-ky/strings.xml
new file mode 100644
index 0000000..f278353
--- /dev/null
+++ b/car-assist-client-lib/res/values-ky/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Жардамчы бул аракетти аткара албайт!"</string>
+    <string name="says" msgid="8575666015622916107">"төмөнкүнү айтты:"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-lo/strings.xml b/car-assist-client-lib/res/values-lo/strings.xml
new file mode 100644
index 0000000..80c7d53
--- /dev/null
+++ b/car-assist-client-lib/res/values-lo/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"ບໍ່ສາມາດຂໍການດຳເນີນການຈາກຜູ້ຊ່ວຍໄດ້!"</string>
+    <string name="says" msgid="8575666015622916107">"ເວົ້າ"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-lt/strings.xml b/car-assist-client-lib/res/values-lt/strings.xml
new file mode 100644
index 0000000..87374c1
--- /dev/null
+++ b/car-assist-client-lib/res/values-lt/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Nepavyko pateikti Padėjėjui veiksmo užklausos!"</string>
+    <string name="says" msgid="8575666015622916107">"sako"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-lv/strings.xml b/car-assist-client-lib/res/values-lv/strings.xml
new file mode 100644
index 0000000..3223c67
--- /dev/null
+++ b/car-assist-client-lib/res/values-lv/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Nevarēja pieprasīt darbību no Asistenta."</string>
+    <string name="says" msgid="8575666015622916107">"saka"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-mk/strings.xml b/car-assist-client-lib/res/values-mk/strings.xml
new file mode 100644
index 0000000..08f56ac
--- /dev/null
+++ b/car-assist-client-lib/res/values-mk/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Не може да се побара дејство од „Помошникот“!"</string>
+    <string name="says" msgid="8575666015622916107">"вели"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-ml/strings.xml b/car-assist-client-lib/res/values-ml/strings.xml
new file mode 100644
index 0000000..71bc6ad
--- /dev/null
+++ b/car-assist-client-lib/res/values-ml/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"അസിസ്‌റ്റന്റിൽ നിന്ന് പ്രവർത്തനം അഭ്യർത്ഥിക്കാനായില്ല!"</string>
+    <string name="says" msgid="8575666015622916107">"പറയുന്നു"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-mn/strings.xml b/car-assist-client-lib/res/values-mn/strings.xml
new file mode 100644
index 0000000..3050b61
--- /dev/null
+++ b/car-assist-client-lib/res/values-mn/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Туслахаас үйлдэл хийхийг хүсэж чадсангүй!"</string>
+    <string name="says" msgid="8575666015622916107">"хэлэхдээ"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-mr/strings.xml b/car-assist-client-lib/res/values-mr/strings.xml
new file mode 100644
index 0000000..a896ce6
--- /dev/null
+++ b/car-assist-client-lib/res/values-mr/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"असिस्टंटकडे क्रियेची विनंती करता आली नाही!"</string>
+    <string name="says" msgid="8575666015622916107">"म्हणाले"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-ms/strings.xml b/car-assist-client-lib/res/values-ms/strings.xml
new file mode 100644
index 0000000..aa8192b
--- /dev/null
+++ b/car-assist-client-lib/res/values-ms/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Tidak dapat meminta tindakan daripada Assistant!"</string>
+    <string name="says" msgid="8575666015622916107">"berkata"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-my/strings.xml b/car-assist-client-lib/res/values-my/strings.xml
new file mode 100644
index 0000000..54ac60f
--- /dev/null
+++ b/car-assist-client-lib/res/values-my/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Assistant မှ လုပ်ဆောင်ချက်ကို တောင်းဆို၍မရပါ။"</string>
+    <string name="says" msgid="8575666015622916107">"ဆိုထားသည်မှာ"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-nb/strings.xml b/car-assist-client-lib/res/values-nb/strings.xml
new file mode 100644
index 0000000..279b16b
--- /dev/null
+++ b/car-assist-client-lib/res/values-nb/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Kunne ikke forespørre handlinger fra assistenten!"</string>
+    <string name="says" msgid="8575666015622916107">"sier"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-ne/strings.xml b/car-assist-client-lib/res/values-ne/strings.xml
new file mode 100644
index 0000000..d20a73a
--- /dev/null
+++ b/car-assist-client-lib/res/values-ne/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"सहायकलाई कारबाही गर्ने अनुरोध गर्न सकिएन!"</string>
+    <string name="says" msgid="8575666015622916107">"भन्नुहुन्छ"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-nl/strings.xml b/car-assist-client-lib/res/values-nl/strings.xml
new file mode 100644
index 0000000..aca2bb7
--- /dev/null
+++ b/car-assist-client-lib/res/values-nl/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Kan actie niet aanvragen bij de Assistent."</string>
+    <string name="says" msgid="8575666015622916107">"zegt"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-or/strings.xml b/car-assist-client-lib/res/values-or/strings.xml
new file mode 100644
index 0000000..81480e1
--- /dev/null
+++ b/car-assist-client-lib/res/values-or/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"ଆସିଷ୍ଟାଣ୍ଟ ଠାରୁ କାର୍ଯ୍ୟ ଅନୁରୋଧ କରାଯାଇପାରିଲା ନାହିଁ!"</string>
+    <string name="says" msgid="8575666015622916107">"କୁହେ"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-pa/strings.xml b/car-assist-client-lib/res/values-pa/strings.xml
new file mode 100644
index 0000000..22fc049
--- /dev/null
+++ b/car-assist-client-lib/res/values-pa/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"\'ਅਸਿਸਟੈਂਟ\' ਤੋਂ ਕਾਰਵਾਈ ਦੀ ਬੇਨਤੀ ਨਹੀਂ ਕੀਤੀ ਜਾ ਸਕਦੀ!"</string>
+    <string name="says" msgid="8575666015622916107">"ਕਿਹਾ"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-pl/strings.xml b/car-assist-client-lib/res/values-pl/strings.xml
new file mode 100644
index 0000000..4ccfa00
--- /dev/null
+++ b/car-assist-client-lib/res/values-pl/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Nie udało się wysłać prośby do Asystenta."</string>
+    <string name="says" msgid="8575666015622916107">"mówi"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-pt-rPT/strings.xml b/car-assist-client-lib/res/values-pt-rPT/strings.xml
new file mode 100644
index 0000000..bb902ea
--- /dev/null
+++ b/car-assist-client-lib/res/values-pt-rPT/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Não foi possível solicitar a ação do Assistente."</string>
+    <string name="says" msgid="8575666015622916107">"diz"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-pt/strings.xml b/car-assist-client-lib/res/values-pt/strings.xml
new file mode 100644
index 0000000..bb902ea
--- /dev/null
+++ b/car-assist-client-lib/res/values-pt/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Não foi possível solicitar a ação do Assistente."</string>
+    <string name="says" msgid="8575666015622916107">"diz"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-ro/strings.xml b/car-assist-client-lib/res/values-ro/strings.xml
new file mode 100644
index 0000000..45cfcb6
--- /dev/null
+++ b/car-assist-client-lib/res/values-ro/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Nu s-a putut solicita acțiunea de la Asistent!"</string>
+    <string name="says" msgid="8575666015622916107">"spune"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-ru/strings.xml b/car-assist-client-lib/res/values-ru/strings.xml
new file mode 100644
index 0000000..7c668c1
--- /dev/null
+++ b/car-assist-client-lib/res/values-ru/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Не удалось выполнить действие с помощью Ассистента"</string>
+    <string name="says" msgid="8575666015622916107">"говорит:"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-si/strings.xml b/car-assist-client-lib/res/values-si/strings.xml
new file mode 100644
index 0000000..0a233a0
--- /dev/null
+++ b/car-assist-client-lib/res/values-si/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"සහායකගෙන් ක්‍රියාව ඉල්ලීමට නොහැකි විය!"</string>
+    <string name="says" msgid="8575666015622916107">"කියයි"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-sk/strings.xml b/car-assist-client-lib/res/values-sk/strings.xml
new file mode 100644
index 0000000..8043b1e
--- /dev/null
+++ b/car-assist-client-lib/res/values-sk/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Vyžiadanie akcie od Asistenta zlyhalo."</string>
+    <string name="says" msgid="8575666015622916107">"hovorí"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-sl/strings.xml b/car-assist-client-lib/res/values-sl/strings.xml
new file mode 100644
index 0000000..ab58a0a
--- /dev/null
+++ b/car-assist-client-lib/res/values-sl/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Ni bilo mogoče zahtevati dejanja Pomočnika."</string>
+    <string name="says" msgid="8575666015622916107">"pravi"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-sq/strings.xml b/car-assist-client-lib/res/values-sq/strings.xml
new file mode 100644
index 0000000..acc0431
--- /dev/null
+++ b/car-assist-client-lib/res/values-sq/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Nuk mund të kërkohet veprim nga \"Asistenti\"!"</string>
+    <string name="says" msgid="8575666015622916107">"thotë"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-sr/strings.xml b/car-assist-client-lib/res/values-sr/strings.xml
new file mode 100644
index 0000000..7d73ea8
--- /dev/null
+++ b/car-assist-client-lib/res/values-sr/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Слање захтева за радњу Помоћника није успело!"</string>
+    <string name="says" msgid="8575666015622916107">"каже"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-sv/strings.xml b/car-assist-client-lib/res/values-sv/strings.xml
new file mode 100644
index 0000000..d22371e
--- /dev/null
+++ b/car-assist-client-lib/res/values-sv/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Det gick inte att begära åtgärden från assistenten."</string>
+    <string name="says" msgid="8575666015622916107">"säger"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-sw/strings.xml b/car-assist-client-lib/res/values-sw/strings.xml
new file mode 100644
index 0000000..dcbddff
--- /dev/null
+++ b/car-assist-client-lib/res/values-sw/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Imeshndwa kuomba kitendo kutoka kwenye programu ya Mratibu wa Google!"</string>
+    <string name="says" msgid="8575666015622916107">"anasema"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-ta/strings.xml b/car-assist-client-lib/res/values-ta/strings.xml
new file mode 100644
index 0000000..6128727
--- /dev/null
+++ b/car-assist-client-lib/res/values-ta/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"அசிஸ்டண்ட்டிடம் இருந்து உதவியைக் கோர இயலவில்லை!"</string>
+    <string name="says" msgid="8575666015622916107">"கூறுகிறார்"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-te/strings.xml b/car-assist-client-lib/res/values-te/strings.xml
new file mode 100644
index 0000000..222ddf4
--- /dev/null
+++ b/car-assist-client-lib/res/values-te/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"అసిస్టెంట్ నుండి చర్యను అభ్యర్థించడం సాధ్యపడలేదు!"</string>
+    <string name="says" msgid="8575666015622916107">"ఇలా చెప్పారు"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-th/strings.xml b/car-assist-client-lib/res/values-th/strings.xml
new file mode 100644
index 0000000..d88bdb1
--- /dev/null
+++ b/car-assist-client-lib/res/values-th/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"การขอให้ Assistant ดำเนินการไม่สำเร็จ"</string>
+    <string name="says" msgid="8575666015622916107">"พูดว่า"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-tl/strings.xml b/car-assist-client-lib/res/values-tl/strings.xml
new file mode 100644
index 0000000..2bcb098
--- /dev/null
+++ b/car-assist-client-lib/res/values-tl/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Hindi makahiling ng pagkilos mula sa Assistant!"</string>
+    <string name="says" msgid="8575666015622916107">"ay nagsabing"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-tr/strings.xml b/car-assist-client-lib/res/values-tr/strings.xml
new file mode 100644
index 0000000..6ef140b
--- /dev/null
+++ b/car-assist-client-lib/res/values-tr/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"İşlem Asistan\'dan istenemedi!"</string>
+    <string name="says" msgid="8575666015622916107">"der ki:"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-uk/strings.xml b/car-assist-client-lib/res/values-uk/strings.xml
new file mode 100644
index 0000000..8ba7886
--- /dev/null
+++ b/car-assist-client-lib/res/values-uk/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Не вдалося надіслати запит на дію Асистента."</string>
+    <string name="says" msgid="8575666015622916107">"говорить"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-ur/strings.xml b/car-assist-client-lib/res/values-ur/strings.xml
new file mode 100644
index 0000000..5e248a8
--- /dev/null
+++ b/car-assist-client-lib/res/values-ur/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"\'اسسٹنٹ\' کی طرف سے کارروائی کی درخواست نہیں کی جا سکی!"</string>
+    <string name="says" msgid="8575666015622916107">"کہ رہا ہے"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-uz/strings.xml b/car-assist-client-lib/res/values-uz/strings.xml
new file mode 100644
index 0000000..3b89e4e
--- /dev/null
+++ b/car-assist-client-lib/res/values-uz/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Assistent orqali amal soʻrovi yuborilmadi!"</string>
+    <string name="says" msgid="8575666015622916107">"dedi:"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-vi/strings.xml b/car-assist-client-lib/res/values-vi/strings.xml
new file mode 100644
index 0000000..4832f26
--- /dev/null
+++ b/car-assist-client-lib/res/values-vi/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Không thể yêu cầu hành động từ Trợ lý!"</string>
+    <string name="says" msgid="8575666015622916107">"nói"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-zh-rCN/strings.xml b/car-assist-client-lib/res/values-zh-rCN/strings.xml
new file mode 100644
index 0000000..637124f
--- /dev/null
+++ b/car-assist-client-lib/res/values-zh-rCN/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"无法从 Google 助理请求操作！"</string>
+    <string name="says" msgid="8575666015622916107">"说"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-zh-rHK/strings.xml b/car-assist-client-lib/res/values-zh-rHK/strings.xml
new file mode 100644
index 0000000..1c22eee
--- /dev/null
+++ b/car-assist-client-lib/res/values-zh-rHK/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"「Google 助理」無法執行要求的操作！"</string>
+    <string name="says" msgid="8575666015622916107">"話"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-zh-rTW/strings.xml b/car-assist-client-lib/res/values-zh-rTW/strings.xml
new file mode 100644
index 0000000..2b73ccf
--- /dev/null
+++ b/car-assist-client-lib/res/values-zh-rTW/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"無法要求 Google 助理執行動作！"</string>
+    <string name="says" msgid="8575666015622916107">"說"</string>
+</resources>
diff --git a/car-assist-client-lib/res/values-zu/strings.xml b/car-assist-client-lib/res/values-zu/strings.xml
new file mode 100644
index 0000000..1fcd4cc
--- /dev/null
+++ b/car-assist-client-lib/res/values-zu/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="assist_action_failed_toast" msgid="3250146468076483714">"Ayikwazanga ukucela isenzo kusuka kumsizi!"</string>
+    <string name="says" msgid="8575666015622916107">"ithi"</string>
+</resources>
diff --git a/car-assist-client-lib/src/com/android/car/assist/client/CarAssistUtils.java b/car-assist-client-lib/src/com/android/car/assist/client/CarAssistUtils.java
index 1ef55cc..029467e 100644
--- a/car-assist-client-lib/src/com/android/car/assist/client/CarAssistUtils.java
+++ b/car-assist-client-lib/src/com/android/car/assist/client/CarAssistUtils.java
@@ -17,6 +17,7 @@
 
 import static android.app.Notification.Action.SEMANTIC_ACTION_MARK_AS_READ;
 import static android.app.Notification.Action.SEMANTIC_ACTION_REPLY;
+import static android.service.voice.VoiceInteractionSession.SHOW_SOURCE_NOTIFICATION;
 
 import static com.android.car.assist.CarVoiceInteractionSession.EXCEPTION_NOTIFICATION_LISTENER_PERMISSIONS_MISSING;
 
@@ -35,6 +36,7 @@
 
 import com.android.car.assist.CarVoiceInteractionSession;
 import com.android.internal.app.AssistUtils;
+import com.android.internal.app.IVoiceActionCheckCallback;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -342,26 +344,41 @@
                 handleFallback(sbn, action, callback);
             } else {
                 // If there is an active assistant, alert them to request permissions.
-                String resultState = requestHandleMissingPermission()
-                        ? ActionRequestCallback.RESULT_FAILED_WITH_ERROR_HANDLED
-                        : ActionRequestCallback.RESULT_FAILED;
-                callback.onResult(resultState);
+                Bundle handleExceptionBundle = BundleBuilder
+                        .buildAssistantHandleExceptionBundle(
+                                EXCEPTION_NOTIFICATION_LISTENER_PERMISSIONS_MISSING);
+                fireAssistantAction(CarVoiceInteractionSession.VOICE_ACTION_HANDLE_EXCEPTION,
+                        handleExceptionBundle, callback);
             }
             return;
         }
 
-        boolean success = mAssistUtils.showSessionForActiveService(payloadArguments,
-                CarVoiceInteractionSession.SHOW_SOURCE_NOTIFICATION, null, null);
-        String resultState = ActionRequestCallback.RESULT_FAILED;
-        if (success) {
-            if (Log.isLoggable(TAG, Log.DEBUG)) {
-                Log.d(TAG, "Launching active assistant for action: " + action);
+        fireAssistantAction(action, payloadArguments, callback);
+    }
+
+    private void fireAssistantAction(String action, Bundle payloadArguments,
+            ActionRequestCallback callback) {
+        IVoiceActionCheckCallback actionCheckCallback = new IVoiceActionCheckCallback.Stub() {
+            @Override
+            public void onComplete(List<String> supportedActions) {
+                String resultState = ActionRequestCallback.RESULT_FAILED;
+                if (supportedActions != null && supportedActions.contains(action)) {
+                    if (Log.isLoggable(TAG, Log.DEBUG)) {
+                        Log.d(TAG, "Launching active Assistant for action: " + action);
+                    }
+                    if (mAssistUtils.showSessionForActiveService(payloadArguments,
+                            SHOW_SOURCE_NOTIFICATION, null, null)) {
+                        resultState = ActionRequestCallback.RESULT_SUCCESS;
+                    }
+                } else {
+                    Log.w(TAG, "Active Assistant does not support voice action: " + action);
+                }
+                callback.onResult(resultState);
             }
-            resultState = ActionRequestCallback.RESULT_SUCCESS;
-        } else {
-            Log.w(TAG, "Failed to launch active assistant.");
-        }
-        callback.onResult(resultState);
+        };
+
+        Set<String> actionSet = new HashSet<>(Collections.singletonList(action));
+        mAssistUtils.getActiveServiceSupportedActions(actionSet, actionCheckCallback);
     }
 
     private void handleFallback(StatusBarNotification sbn, String action,
@@ -369,15 +386,31 @@
         FallbackAssistant.Listener listener = new FallbackAssistant.Listener() {
             @Override
             public void onMessageRead(boolean hasError) {
-                String resultState = hasError ? ActionRequestCallback.RESULT_FAILED
+                // Tracks if the FallbackAssistant successfully handled the action.
+                final String fallbackActionResult = hasError ? ActionRequestCallback.RESULT_FAILED
                         : ActionRequestCallback.RESULT_SUCCESS;
-                // Only change the resultState if fallback failed, and assistant successfully
-                // alerted to prompt user for permissions.
-                if (hasActiveAssistant() && requestHandleMissingPermission()
-                        && resultState.equals(ActionRequestCallback.RESULT_FAILED)) {
-                    resultState = ActionRequestCallback.RESULT_FAILED_WITH_ERROR_HANDLED;
+                if (hasActiveAssistant()) {
+                    fireAssistantAction(CarVoiceInteractionSession.VOICE_ACTION_HANDLE_EXCEPTION,
+                            null, new ActionRequestCallback() {
+                                @Override
+                                public void onResult(String requestActionFromAssistantResult) {
+                                    if (fallbackActionResult.equals(
+                                            ActionRequestCallback.RESULT_FAILED)
+                                            && requestActionFromAssistantResult
+                                            == ActionRequestCallback.RESULT_SUCCESS) {
+                                        // Only change the callback.ResultState if fallback failed,
+                                        // and assistant session is shown.
+                                        callback.onResult(
+                                                ActionRequestCallback
+                                                        .RESULT_FAILED_WITH_ERROR_HANDLED);
+                                    } else {
+                                        callback.onResult(fallbackActionResult);
+                                    }
+                                }
+                            });
+                } else {
+                    callback.onResult(fallbackActionResult);
                 }
-                callback.onResult(resultState);
             }
         };
 
@@ -394,21 +427,4 @@
                 return;
         }
     }
-
-    /**
-     * Requests the active voice service to handle the permissions missing error.
-     *
-     * @return {@code true} if active assistant was successfully alerted.
-     **/
-    private boolean requestHandleMissingPermission() {
-        Bundle payloadArguments = BundleBuilder
-                .buildAssistantHandleExceptionBundle(
-                        EXCEPTION_NOTIFICATION_LISTENER_PERMISSIONS_MISSING);
-        boolean requestedSuccessfully = mAssistUtils.showSessionForActiveService(payloadArguments,
-                CarVoiceInteractionSession.SHOW_SOURCE_NOTIFICATION, null, null);
-        if (!requestedSuccessfully) {
-            Log.w(TAG, "Failed to alert assistant to request permissions from user");
-        }
-        return requestedSuccessfully;
-    }
 }
diff --git a/car-assist-client-lib/tests/Android.mk b/car-assist-client-lib/tests/Android.mk
deleted file mode 100644
index 9f0a4e8..0000000
--- a/car-assist-client-lib/tests/Android.mk
+++ /dev/null
@@ -1,19 +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.
-
-LOCAL_PATH := $(call my-dir)
-include $(CLEAR_VARS)
-
-# Include all makefiles in subdirectories
-include $(call all-makefiles-under,$(LOCAL_PATH))
diff --git a/car-assist-client-lib/tests/robotests/Android.mk b/car-assist-client-lib/tests/robotests/Android.mk
deleted file mode 100644
index 93613b6..0000000
--- a/car-assist-client-lib/tests/robotests/Android.mk
+++ /dev/null
@@ -1,78 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-
-############################################################
-# CarAssistClient app just for Robolectric test target.     #
-############################################################
-include $(CLEAR_VARS)
-
-LOCAL_RESOURCE_DIR := $(LOCAL_PATH)/res
-
-LOCAL_PACKAGE_NAME := CarAssistClient
-LOCAL_PRIVATE_PLATFORM_APIS := true
-LOCAL_MODULE_TAGS := optional
-
-LOCAL_USE_AAPT2 := true
-
-LOCAL_PRIVILEGED_MODULE := true
-
-LOCAL_JAVA_LIBRARIES := android.car
-
-LOCAL_STATIC_ANDROID_LIBRARIES := \
-    car-assist-client-lib
-
-include $(BUILD_PACKAGE)
-
-#############################################
-# Car-Assist-Client Robolectric test target. #
-#############################################
-include $(CLEAR_VARS)
-
-LOCAL_MODULE := CarAssistClientRoboTests
-LOCAL_MODULE_CLASS := JAVA_LIBRARIES
-
-LOCAL_SRC_FILES := $(call all-java-files-under, src)
-
-LOCAL_JAVA_RESOURCE_DIRS := config
-
-# Include the testing libraries
-LOCAL_JAVA_LIBRARIES := \
-    android.car \
-    robolectric_android-all-stub \
-    Robolectric_all-target \
-    mockito-robolectric-prebuilt \
-    truth-prebuilt
-
-LOCAL_INSTRUMENTATION_FOR := CarAssistClient
-
-LOCAL_MODULE_TAGS := optional
-
-include $(BUILD_STATIC_JAVA_LIBRARY)
-
-#############################################################
-# CarAssistClient runner target to run the previous target. #
-#############################################################
-include $(CLEAR_VARS)
-
-LOCAL_MODULE := RunCarAssistClientRoboTests
-
-LOCAL_SDK_VERSION := current
-
-LOCAL_STATIC_JAVA_LIBRARIES := \
-    CarAssistClientRoboTests
-
-LOCAL_JAVA_LIBRARIES := \
-    CarAssistClientRoboTests \
-    robolectric_android-all-stub \
-    Robolectric_all-target \
-    mockito-robolectric-prebuilt \
-    truth-prebuilt \
-    android.car
-
-LOCAL_TEST_PACKAGE := CarAssistClient
-
-LOCAL_ROBOTEST_FILES := \
-    $(call find-files-in-subdirs,$(LOCAL_PATH)/src,*Test.java,.))
-
-LOCAL_INSTRUMENT_SOURCE_DIRS := $(dir $(LOCAL_PATH))../src
-
-include external/robolectric-shadows/run_robotests.mk
diff --git a/car-assist-client-lib/tests/robotests/AndroidManifest.xml b/car-assist-client-lib/tests/robotests/AndroidManifest.xml
deleted file mode 100644
index f744c6c..0000000
--- a/car-assist-client-lib/tests/robotests/AndroidManifest.xml
+++ /dev/null
@@ -1,21 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-    Copyright (C) 2019 Google Inc.
-
-    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.
--->
-
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.android.car.assist.client.robotests">
-
-</manifest>
diff --git a/car-assist-client-lib/tests/robotests/config/robolectric_properties b/car-assist-client-lib/tests/robotests/config/robolectric_properties
deleted file mode 100644
index 12ca377..0000000
--- a/car-assist-client-lib/tests/robotests/config/robolectric_properties
+++ /dev/null
@@ -1,17 +0,0 @@
-#
-# Copyright (C) 2019 Google Inc.
-#
-# 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.
-#
-manifest=packages/apps/Car/libs/car-assist-client-lib/tests/robotests/AndroidManifest.xml
-sdk=NEWEST_SDK
diff --git a/car-assist-client-lib/tests/robotests/src/com/android/car/assist/client/CarAssistUtilsTest.java b/car-assist-client-lib/tests/robotests/src/com/android/car/assist/client/CarAssistUtilsTest.java
deleted file mode 100644
index 8e9770f..0000000
--- a/car-assist-client-lib/tests/robotests/src/com/android/car/assist/client/CarAssistUtilsTest.java
+++ /dev/null
@@ -1,152 +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.car.assist.client;
-
-import static com.google.common.truth.Truth.assertThat;
-
-import android.app.Notification;
-import android.app.PendingIntent;
-import android.content.Context;
-import android.content.Intent;
-import android.os.UserHandle;
-import android.service.notification.StatusBarNotification;
-
-import androidx.core.app.NotificationCompat;
-import androidx.core.app.NotificationCompat.Action;
-import androidx.core.app.NotificationCompat.MessagingStyle;
-import androidx.core.app.Person;
-import androidx.core.app.RemoteInput;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.robolectric.RobolectricTestRunner;
-import org.robolectric.RuntimeEnvironment;
-import org.robolectric.annotation.Config;
-
-@RunWith(RobolectricTestRunner.class)
-@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
-public class CarAssistUtilsTest {
-
-    private Context mContext;
-    private static final String PKG_1 = "package_1";
-    private static final String OP_PKG = "OpPackage";
-    private static final int ID = 1;
-    private static final String TAG = "Tag";
-    private static final int UID = 2;
-    private static final int INITIAL_PID = 3;
-    private static final String CHANNEL_ID = "CHANNEL_ID";
-    private static final String CONTENT_TITLE = "CONTENT_TITLE";
-    private static final String STATIC_USER_NAME = "STATIC_USER_NAME";
-    private static final String SENDER_NAME = "Larry";
-    private static final String SENDER_CONTACT_URI = "TEST_SENDER_URI";
-    private static final String REMOTE_INPUT_KEY = "REMOTE_INPUT_KEY";
-    private static final String REPLY_ACTION = "test.package.REPLY";
-    private static final String READ_ACTION = "test.package.READ";
-    private static final long POST_TIME = 12345L;
-    private static final int ICON = android.R.drawable.ic_media_play;
-    private static final String OVERRIDE_GROUP_KEY = "OVERRIDE_GROUP_KEY";
-    private static final UserHandle USER_HANDLE = new UserHandle(12);
-
-    @Before
-    public void setup() {
-        mContext = RuntimeEnvironment.application;
-    }
-
-    @Test
-    public void testCarCompatMessagingNotification_qualifyingNotification() {
-        assertThat(CarAssistUtils.isCarCompatibleMessagingNotification(
-                buildStatusBarNotification(/* hasReplyAction */ true, /* hasMessagingStyle */
-                        true))).isTrue();
-    }
-
-    @Test
-    public void testCarCompatMessagingNotification_noReplyNotification() {
-        assertThat(CarAssistUtils.isCarCompatibleMessagingNotification(
-                buildStatusBarNotification(/* hasReplyAction */ false, /* hasMessagingStyle */
-                        true))).isTrue();
-    }
-
-    @Test
-    public void testCarCompatMessagingNotifcation_noMessagingStyleNotification() {
-        assertThat(CarAssistUtils.isCarCompatibleMessagingNotification(
-                buildStatusBarNotification(/* hasReplyAction */ true, /* hasMessagingStyle */
-                        false))).isFalse();
-    }
-
-    private StatusBarNotification buildStatusBarNotification(boolean hasReplyAction,
-            boolean hasMessagingStyle) {
-
-        NotificationCompat.Builder builder = new NotificationCompat.Builder(mContext, CHANNEL_ID)
-                .setContentTitle(CONTENT_TITLE)
-                .setCategory(Notification.CATEGORY_MESSAGE)
-                .addAction(buildMarkAsReadAction())
-                .setShowWhen(true);
-
-        if (hasReplyAction) {
-            builder.addAction(buildReplyAction());
-        }
-
-        if (hasMessagingStyle) {
-            builder.setStyle(buildMessagingStyle());
-        }
-
-        return new StatusBarNotification(PKG_1, OP_PKG,
-                ID, TAG, UID, INITIAL_PID, builder.build(), USER_HANDLE,
-                OVERRIDE_GROUP_KEY, POST_TIME);
-    }
-
-    private Action buildMarkAsReadAction() {
-        Intent intent = new Intent(mContext, this.getClass()).setAction(READ_ACTION);
-        PendingIntent pendingIntent = PendingIntent.getService(mContext, 0, intent,
-                PendingIntent.FLAG_UPDATE_CURRENT);
-        return new Action.Builder(ICON, "read", pendingIntent)
-                .setSemanticAction(Action.SEMANTIC_ACTION_MARK_AS_READ)
-                .setShowsUserInterface(false)
-                .build();
-    }
-
-    private Action buildReplyAction() {
-        Intent intent = new Intent(mContext, this.getClass())
-                .setAction(REPLY_ACTION);
-        PendingIntent replyIntent = PendingIntent.getService(mContext, 0, intent,
-                PendingIntent.FLAG_UPDATE_CURRENT);
-
-        return new Action.Builder(ICON,
-                "reply", replyIntent)
-                .setSemanticAction(Action.SEMANTIC_ACTION_REPLY)
-                .setShowsUserInterface(false)
-                .addRemoteInput(
-                        new RemoteInput.Builder(REMOTE_INPUT_KEY)
-                                .build()
-                )
-                .build();
-    }
-
-    private MessagingStyle buildMessagingStyle() {
-        Person user = new Person.Builder()
-                .setName(STATIC_USER_NAME)
-                .build();
-        NotificationCompat.MessagingStyle messagingStyle =
-                new NotificationCompat.MessagingStyle(user);
-        Person sender = new Person.Builder()
-                .setName(SENDER_NAME)
-                .setUri(SENDER_CONTACT_URI)
-                .build();
-        messagingStyle.addMessage("Hello World", POST_TIME, sender);
-        return messagingStyle;
-    }
-}
diff --git a/car-assist-client-lib/tests/robotests/src/com/android/car/assist/client/TestConfig.java b/car-assist-client-lib/tests/robotests/src/com/android/car/assist/client/TestConfig.java
deleted file mode 100644
index 6c2a92b..0000000
--- a/car-assist-client-lib/tests/robotests/src/com/android/car/assist/client/TestConfig.java
+++ /dev/null
@@ -1,23 +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.car.assist.client;
-
-public class TestConfig {
-    public static final int SDK_VERSION = 28;
-    public static final String MANIFEST_PATH =
-            "packages/apps/Car/libs/car-assist-client-lib/AndroidManifest.xml";
-}
diff --git a/car-assist-lib/Android.bp b/car-assist-lib/Android.bp
new file mode 100644
index 0000000..4f8f578
--- /dev/null
+++ b/car-assist-lib/Android.bp
@@ -0,0 +1,33 @@
+//
+// 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.
+//
+
+android_library {
+    name: "car-assist-lib",
+
+    srcs: ["src/**/*.java"],
+
+    optimize: {
+        enabled: false,
+    },
+
+    sdk_version: "current",
+
+    static_libs: [
+        "androidx.legacy_legacy-support-v4",
+        "androidx.annotation_annotation",
+    ],
+
+}
diff --git a/car-assist-lib/Android.mk b/car-assist-lib/Android.mk
deleted file mode 100644
index 434b912..0000000
--- a/car-assist-lib/Android.mk
+++ /dev/null
@@ -1,41 +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.
-#
-
-LOCAL_PATH:= $(call my-dir)
-
-include $(CLEAR_VARS)
-
-LOCAL_SRC_FILES := $(call all-java-files-under, src)
-
-LOCAL_MODULE := car-assist-lib
-
-LOCAL_MODULE_TAGS := optional
-
-LOCAL_PRIVILEGED_MODULE := true
-
-LOCAL_PROGUARD_ENABLED := disabled
-
-LOCAL_SDK_VERSION := 28
-
-LOCAL_USE_AAPT2 := true
-
-LOCAL_STATIC_ANDROID_LIBRARIES += \
-    androidx.legacy_legacy-support-v4 \
-
-LOCAL_STATIC_JAVA_LIBRARIES += \
-    androidx.annotation_annotation \
-
-include $(BUILD_STATIC_JAVA_LIBRARY)
diff --git a/car-assist-lib/src/com/android/car/assist/CarVoiceInteractionSession.java b/car-assist-lib/src/com/android/car/assist/CarVoiceInteractionSession.java
index e2c6282..cd58229 100644
--- a/car-assist-lib/src/com/android/car/assist/CarVoiceInteractionSession.java
+++ b/car-assist-lib/src/com/android/car/assist/CarVoiceInteractionSession.java
@@ -32,14 +32,6 @@
  * by the voice session initiator.
  */
 public abstract class CarVoiceInteractionSession extends VoiceInteractionSession {
-
-    // TODO: Use the flag introduced in new API changes, once the changes are available.
-    /**
-     * Flag for use with {@link #onShow}: indicates that the voice interaction service was invoked
-     * from a notification.
-     */
-    public static final int SHOW_SOURCE_NOTIFICATION = 1 << 6;
-
     /** The key used for the action {@link String} in the payload {@link Bundle}. */
     public static final String KEY_ACTION = "KEY_ACTION";
 
diff --git a/car-broadcastradio-support/res/values-af/strings.xml b/car-broadcastradio-support/res/values-af/strings.xml
index d5e5456..0c08586 100644
--- a/car-broadcastradio-support/res/values-af/strings.xml
+++ b/car-broadcastradio-support/res/values-af/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Stasies"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Gunstelinge"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-am/strings.xml b/car-broadcastradio-support/res/values-am/strings.xml
index 4f00976..81b128a 100644
--- a/car-broadcastradio-support/res/values-am/strings.xml
+++ b/car-broadcastradio-support/res/values-am/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"ኤኤም"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"ኤፍኤም"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"ጣቢያዎች"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"ተወዳጆች"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-ar/strings.xml b/car-broadcastradio-support/res/values-ar/strings.xml
index f283332..129c8c5 100644
--- a/car-broadcastradio-support/res/values-ar/strings.xml
+++ b/car-broadcastradio-support/res/values-ar/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"المحطات"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"المفضّلة"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-as/strings.xml b/car-broadcastradio-support/res/values-as/strings.xml
index a161349..862e9bb 100644
--- a/car-broadcastradio-support/res/values-as/strings.xml
+++ b/car-broadcastradio-support/res/values-as/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"কেন্দ্ৰসমূহ"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"প্ৰিয় বস্তুসমূহ"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-az/strings.xml b/car-broadcastradio-support/res/values-az/strings.xml
index 0391a41..3b40ff9 100644
--- a/car-broadcastradio-support/res/values-az/strings.xml
+++ b/car-broadcastradio-support/res/values-az/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Stansiyalar"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Sevimlilər"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-b+sr+Latn/strings.xml b/car-broadcastradio-support/res/values-b+sr+Latn/strings.xml
index 667f33c..e29e90e 100644
--- a/car-broadcastradio-support/res/values-b+sr+Latn/strings.xml
+++ b/car-broadcastradio-support/res/values-b+sr+Latn/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Stanice"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Omiljeno"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-be/strings.xml b/car-broadcastradio-support/res/values-be/strings.xml
index 2bc2320..cde54f4 100644
--- a/car-broadcastradio-support/res/values-be/strings.xml
+++ b/car-broadcastradio-support/res/values-be/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Радыёстанцыі"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Абранае"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-bg/strings.xml b/car-broadcastradio-support/res/values-bg/strings.xml
index d5eb23f..6d7b2a0 100644
--- a/car-broadcastradio-support/res/values-bg/strings.xml
+++ b/car-broadcastradio-support/res/values-bg/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"Цифрово радиоразпръскване"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Станции"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Любими"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-bn/strings.xml b/car-broadcastradio-support/res/values-bn/strings.xml
index 8bf2392..245ce98 100644
--- a/car-broadcastradio-support/res/values-bn/strings.xml
+++ b/car-broadcastradio-support/res/values-bn/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"স্টেশন"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"পছন্দসই"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-bs/strings.xml b/car-broadcastradio-support/res/values-bs/strings.xml
index 5515529..42ff388 100644
--- a/car-broadcastradio-support/res/values-bs/strings.xml
+++ b/car-broadcastradio-support/res/values-bs/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Stanice"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Omiljeni"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-ca/strings.xml b/car-broadcastradio-support/res/values-ca/strings.xml
index 3c53c47..3737632 100644
--- a/car-broadcastradio-support/res/values-ca/strings.xml
+++ b/car-broadcastradio-support/res/values-ca/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Emissores"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Preferides"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-cs/strings.xml b/car-broadcastradio-support/res/values-cs/strings.xml
index 49ff604..db20752 100644
--- a/car-broadcastradio-support/res/values-cs/strings.xml
+++ b/car-broadcastradio-support/res/values-cs/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Stanice"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Oblíbené"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-da/strings.xml b/car-broadcastradio-support/res/values-da/strings.xml
index 6a52984..46d1603 100644
--- a/car-broadcastradio-support/res/values-da/strings.xml
+++ b/car-broadcastradio-support/res/values-da/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Kanaler"</string>
-    <string name="favorites_list_text" msgid="7829827713977109155">"Foretrukne"</string>
+    <string name="favorites_list_text" msgid="7829827713977109155">"Favoritter"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-de/strings.xml b/car-broadcastradio-support/res/values-de/strings.xml
index 9fbc815..c6e2e9f 100644
--- a/car-broadcastradio-support/res/values-de/strings.xml
+++ b/car-broadcastradio-support/res/values-de/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"MW"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"UKW"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Sender"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Favoriten"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-el/strings.xml b/car-broadcastradio-support/res/values-el/strings.xml
index 1cece0e..f5452ec 100644
--- a/car-broadcastradio-support/res/values-el/strings.xml
+++ b/car-broadcastradio-support/res/values-el/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Σταθμοί"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Αγαπημένα"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-en-rAU/strings.xml b/car-broadcastradio-support/res/values-en-rAU/strings.xml
index a124c34..806c9c8 100644
--- a/car-broadcastradio-support/res/values-en-rAU/strings.xml
+++ b/car-broadcastradio-support/res/values-en-rAU/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"a.m."</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Stations"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Favourites"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-en-rCA/strings.xml b/car-broadcastradio-support/res/values-en-rCA/strings.xml
index a124c34..806c9c8 100644
--- a/car-broadcastradio-support/res/values-en-rCA/strings.xml
+++ b/car-broadcastradio-support/res/values-en-rCA/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"a.m."</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Stations"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Favourites"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-en-rGB/strings.xml b/car-broadcastradio-support/res/values-en-rGB/strings.xml
index a124c34..806c9c8 100644
--- a/car-broadcastradio-support/res/values-en-rGB/strings.xml
+++ b/car-broadcastradio-support/res/values-en-rGB/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"a.m."</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Stations"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Favourites"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-en-rIN/strings.xml b/car-broadcastradio-support/res/values-en-rIN/strings.xml
index a124c34..806c9c8 100644
--- a/car-broadcastradio-support/res/values-en-rIN/strings.xml
+++ b/car-broadcastradio-support/res/values-en-rIN/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"a.m."</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Stations"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Favourites"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-en-rXC/strings.xml b/car-broadcastradio-support/res/values-en-rXC/strings.xml
index 5741e91..b06db6c 100644
--- a/car-broadcastradio-support/res/values-en-rXC/strings.xml
+++ b/car-broadcastradio-support/res/values-en-rXC/strings.xml
@@ -16,8 +16,9 @@
 
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="radio_am_text" msgid="571324921988967868">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‎‏‏‏‏‏‏‏‏‎‏‏‎‏‏‏‎‎‎‎‎‎‏‏‏‏‏‏‎‏‎‏‎‏‎‎‏‎‎‏‏‏‏‎‏‎‏‏‏‎‏‏‎‏‏‎‏‏‏‏‎‎‎AM‎‏‎‎‏‎"</string>
-    <string name="radio_fm_text" msgid="1973045042281933494">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‎‏‏‏‎‏‏‎‏‏‎‎‎‎‏‏‎‏‎‏‎‏‎‎‎‎‎‎‎‏‏‎‎‏‎‎‏‏‏‎‎‎‎‏‏‏‏‎‏‏‎‏‎‏‎‏‎‏‏‎‏‏‎‎FM‎‏‎‎‏‎"</string>
-    <string name="program_list_text" msgid="4414150317304422313">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‏‎‏‏‏‏‎‏‎‏‎‎‎‎‏‎‎‎‏‏‎‏‏‎‎‏‎‏‎‎‏‏‏‎‎‏‎‎‎‎‎‎‎‏‏‎‏‏‏‎‎‏‏‏‏‏‏‎‏‎‏‎‎‏‎Stations‎‏‎‎‏‎"</string>
-    <string name="favorites_list_text" msgid="7829827713977109155">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‏‏‏‏‎‏‏‎‎‏‎‏‎‏‎‎‏‎‎‏‎‎‎‏‎‏‏‎‏‎‎‏‎‎‏‎‏‏‎‎‎‎‎‎‏‏‏‎‏‎‏‎‎‏‎‏‎‏‎‏‎‎‎‏‏‎Favorites‎‏‎‎‏‎"</string>
+    <string name="radio_am_text" msgid="571324921988967868">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‎‏‏‏‏‏‏‏‏‎‏‏‎‏‏‏‎‎‎‎‎‎‏‏‏‏‏‏‎‏‎‏‎‏‎‎‏‎‎‏‏‏‏‎‏‎‏‏‏‎‏‏‎‏‏‎‏‏‏‏‎‎‎AM‎‏‎‎‏‎"</string>
+    <string name="radio_fm_text" msgid="1973045042281933494">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‎‏‏‏‎‏‏‎‏‏‎‎‎‎‏‏‎‏‎‏‎‏‎‎‎‎‎‎‎‏‏‎‎‏‎‎‏‏‏‎‎‎‎‏‏‏‏‎‏‏‎‏‎‏‎‏‎‏‏‎‏‏‎‎FM‎‏‎‎‏‎"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‏‏‏‏‏‎‏‎‏‎‏‎‏‏‎‏‏‎‏‎‏‎‏‏‏‏‏‏‏‏‎‏‏‎‏‎‏‎‎‏‏‎‏‏‏‎‎‏‎‎‏‎‏‏‎‎‏‏‎‎‏‎‎‏‏‎DAB‎‏‎‎‏‎"</string>
+    <string name="program_list_text" msgid="4414150317304422313">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‏‎‏‏‏‏‎‏‎‏‎‎‎‎‏‎‎‎‏‏‎‏‏‎‎‏‎‏‎‎‏‏‏‎‎‏‎‎‎‎‎‎‎‏‏‎‏‏‏‎‎‏‏‏‏‏‏‎‏‎‏‎‎‏‎Stations‎‏‎‎‏‎"</string>
+    <string name="favorites_list_text" msgid="7829827713977109155">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‏‏‏‏‎‏‏‎‎‏‎‏‎‏‎‎‏‎‎‏‎‎‎‏‎‏‏‎‏‎‎‏‎‎‏‎‏‏‎‎‎‎‎‎‏‏‏‎‏‎‏‎‎‏‎‏‎‏‎‏‎‎‎‏‏‎Favorites‎‏‎‎‏‎"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-es-rUS/strings.xml b/car-broadcastradio-support/res/values-es-rUS/strings.xml
index e5353a3..4862ab2 100644
--- a/car-broadcastradio-support/res/values-es-rUS/strings.xml
+++ b/car-broadcastradio-support/res/values-es-rUS/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Estaciones"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Favoritos"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-es/strings.xml b/car-broadcastradio-support/res/values-es/strings.xml
index 99ca44f..f0f383e 100644
--- a/car-broadcastradio-support/res/values-es/strings.xml
+++ b/car-broadcastradio-support/res/values-es/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Emisoras"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Favoritos"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-et/strings.xml b/car-broadcastradio-support/res/values-et/strings.xml
index 90b6b7b..810c07e 100644
--- a/car-broadcastradio-support/res/values-et/strings.xml
+++ b/car-broadcastradio-support/res/values-et/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Jaamad"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Lemmikud"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-eu/strings.xml b/car-broadcastradio-support/res/values-eu/strings.xml
index 4b31bcf..999d986 100644
--- a/car-broadcastradio-support/res/values-eu/strings.xml
+++ b/car-broadcastradio-support/res/values-eu/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Kateak"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Gogokoak"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-fa/strings.xml b/car-broadcastradio-support/res/values-fa/strings.xml
index f088ba0..1828fc3 100644
--- a/car-broadcastradio-support/res/values-fa/strings.xml
+++ b/car-broadcastradio-support/res/values-fa/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"ایستگاه‌ها"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"موارد دلخواه"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-fi/strings.xml b/car-broadcastradio-support/res/values-fi/strings.xml
index 1a3a396..a1b60db 100644
--- a/car-broadcastradio-support/res/values-fi/strings.xml
+++ b/car-broadcastradio-support/res/values-fi/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Kanavat"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Suosikit"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-fr-rCA/strings.xml b/car-broadcastradio-support/res/values-fr-rCA/strings.xml
index e064086..89bd122 100644
--- a/car-broadcastradio-support/res/values-fr-rCA/strings.xml
+++ b/car-broadcastradio-support/res/values-fr-rCA/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Stations"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Favorites"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-fr/strings.xml b/car-broadcastradio-support/res/values-fr/strings.xml
index 0c422b8..f12123f 100644
--- a/car-broadcastradio-support/res/values-fr/strings.xml
+++ b/car-broadcastradio-support/res/values-fr/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Radios"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Favoris"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-gl/strings.xml b/car-broadcastradio-support/res/values-gl/strings.xml
index 04d1d05..beccab0 100644
--- a/car-broadcastradio-support/res/values-gl/strings.xml
+++ b/car-broadcastradio-support/res/values-gl/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Emisoras"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Programas favoritos"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-gu/strings.xml b/car-broadcastradio-support/res/values-gu/strings.xml
index 8790a34..8da5f9d 100644
--- a/car-broadcastradio-support/res/values-gu/strings.xml
+++ b/car-broadcastradio-support/res/values-gu/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"સ્ટેશન"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"મનપસંદ"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-hi/strings.xml b/car-broadcastradio-support/res/values-hi/strings.xml
index a9714e9..230e18b 100644
--- a/car-broadcastradio-support/res/values-hi/strings.xml
+++ b/car-broadcastradio-support/res/values-hi/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"एएम रेडियो"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"एफ़एम रेडियो"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"डीएबी"</string>
     <string name="program_list_text" msgid="4414150317304422313">"स्टेशन"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"पसंदीदा"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-hr/strings.xml b/car-broadcastradio-support/res/values-hr/strings.xml
index 9a49cb5..63cc855 100644
--- a/car-broadcastradio-support/res/values-hr/strings.xml
+++ b/car-broadcastradio-support/res/values-hr/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Postaje"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Favoriti"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-hu/strings.xml b/car-broadcastradio-support/res/values-hu/strings.xml
index 98c1ef3..5a16d62 100644
--- a/car-broadcastradio-support/res/values-hu/strings.xml
+++ b/car-broadcastradio-support/res/values-hu/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Állomások"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Kedvencek"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-hy/strings.xml b/car-broadcastradio-support/res/values-hy/strings.xml
index efb09fb..77efc29 100644
--- a/car-broadcastradio-support/res/values-hy/strings.xml
+++ b/car-broadcastradio-support/res/values-hy/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Ռադիոկայաններ"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Ընտրանի"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-in/strings.xml b/car-broadcastradio-support/res/values-in/strings.xml
index c07da35..e40e53f 100644
--- a/car-broadcastradio-support/res/values-in/strings.xml
+++ b/car-broadcastradio-support/res/values-in/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Stasiun"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Favorit"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-is/strings.xml b/car-broadcastradio-support/res/values-is/strings.xml
index 77fc30d..1a2074a 100644
--- a/car-broadcastradio-support/res/values-is/strings.xml
+++ b/car-broadcastradio-support/res/values-is/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Stöðvar"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Eftirlæti"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-it/strings.xml b/car-broadcastradio-support/res/values-it/strings.xml
index a70b1a6..eef0a6e 100644
--- a/car-broadcastradio-support/res/values-it/strings.xml
+++ b/car-broadcastradio-support/res/values-it/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Stazioni"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Preferiti"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-iw/strings.xml b/car-broadcastradio-support/res/values-iw/strings.xml
index 947c790..e990b26 100644
--- a/car-broadcastradio-support/res/values-iw/strings.xml
+++ b/car-broadcastradio-support/res/values-iw/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB ‏(Digital Audio Broadcasting)"</string>
     <string name="program_list_text" msgid="4414150317304422313">"תחנות"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"מועדפים"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-ja/strings.xml b/car-broadcastradio-support/res/values-ja/strings.xml
index 9bf2688..21582d0 100644
--- a/car-broadcastradio-support/res/values-ja/strings.xml
+++ b/car-broadcastradio-support/res/values-ja/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"ステーション"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"お気に入り"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-ka/strings.xml b/car-broadcastradio-support/res/values-ka/strings.xml
index a8c9310..2f26b0a 100644
--- a/car-broadcastradio-support/res/values-ka/strings.xml
+++ b/car-broadcastradio-support/res/values-ka/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"ციფრული აუდიომაუწყებლობა"</string>
     <string name="program_list_text" msgid="4414150317304422313">"სადგურები"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"რჩეულები"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-kk/strings.xml b/car-broadcastradio-support/res/values-kk/strings.xml
index bb42599..740afce 100644
--- a/car-broadcastradio-support/res/values-kk/strings.xml
+++ b/car-broadcastradio-support/res/values-kk/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Станциялар"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Таңдаулылар"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-km/strings.xml b/car-broadcastradio-support/res/values-km/strings.xml
index 1be3e72..be70353 100644
--- a/car-broadcastradio-support/res/values-km/strings.xml
+++ b/car-broadcastradio-support/res/values-km/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB​"</string>
     <string name="program_list_text" msgid="4414150317304422313">"ស្ថានីយ"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"សំណព្វ"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-kn/strings.xml b/car-broadcastradio-support/res/values-kn/strings.xml
index 779ca45..9dadc54 100644
--- a/car-broadcastradio-support/res/values-kn/strings.xml
+++ b/car-broadcastradio-support/res/values-kn/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"ಬೆಳಿಗ್ಗೆ"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"ಸ್ಟೇಶನ್‌ಗಳು"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"ಮೆಚ್ಚಿನವುಗಳು"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-ko/strings.xml b/car-broadcastradio-support/res/values-ko/strings.xml
index 8fbced2..abebfa4 100644
--- a/car-broadcastradio-support/res/values-ko/strings.xml
+++ b/car-broadcastradio-support/res/values-ko/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"채널"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"즐겨찾기"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-ky/strings.xml b/car-broadcastradio-support/res/values-ky/strings.xml
index 0ae3d61..4640491 100644
--- a/car-broadcastradio-support/res/values-ky/strings.xml
+++ b/car-broadcastradio-support/res/values-ky/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Станциялар"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Сүйүктүүлөр"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-lo/strings.xml b/car-broadcastradio-support/res/values-lo/strings.xml
index 4d6965b..fbfe882 100644
--- a/car-broadcastradio-support/res/values-lo/strings.xml
+++ b/car-broadcastradio-support/res/values-lo/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"ສະຖານີ"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"ລາຍການທີ່ມັກ"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-lt/strings.xml b/car-broadcastradio-support/res/values-lt/strings.xml
index d3cbf67..6a68328 100644
--- a/car-broadcastradio-support/res/values-lt/strings.xml
+++ b/car-broadcastradio-support/res/values-lt/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Stotys"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Mėgstamiausi"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-lv/strings.xml b/car-broadcastradio-support/res/values-lv/strings.xml
index 86f6658..75db93a 100644
--- a/car-broadcastradio-support/res/values-lv/strings.xml
+++ b/car-broadcastradio-support/res/values-lv/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Programmas"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Izlase"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-mk/strings.xml b/car-broadcastradio-support/res/values-mk/strings.xml
index 40954a7..c7410af 100644
--- a/car-broadcastradio-support/res/values-mk/strings.xml
+++ b/car-broadcastradio-support/res/values-mk/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Станици"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Омилени"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-ml/strings.xml b/car-broadcastradio-support/res/values-ml/strings.xml
index 37ca2fc..498bfd7 100644
--- a/car-broadcastradio-support/res/values-ml/strings.xml
+++ b/car-broadcastradio-support/res/values-ml/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"രാവിലെ"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"സ്റ്റേഷനുകള്‍"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"പ്രിയപ്പെട്ടവ"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-mn/strings.xml b/car-broadcastradio-support/res/values-mn/strings.xml
index e7d85bc..3deca28 100644
--- a/car-broadcastradio-support/res/values-mn/strings.xml
+++ b/car-broadcastradio-support/res/values-mn/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"ӨГЛӨӨ"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Станцууд"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Дуртай"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-mr/strings.xml b/car-broadcastradio-support/res/values-mr/strings.xml
index 9aa7958..0fc95e4 100644
--- a/car-broadcastradio-support/res/values-mr/strings.xml
+++ b/car-broadcastradio-support/res/values-mr/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"स्टेशन"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"आवडीचे"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-ms/strings.xml b/car-broadcastradio-support/res/values-ms/strings.xml
index 8b6a29b..257cb5e 100644
--- a/car-broadcastradio-support/res/values-ms/strings.xml
+++ b/car-broadcastradio-support/res/values-ms/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Stesen"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Kegemaran"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-my/strings.xml b/car-broadcastradio-support/res/values-my/strings.xml
index dcc5941..692d19d 100644
--- a/car-broadcastradio-support/res/values-my/strings.xml
+++ b/car-broadcastradio-support/res/values-my/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"အသံလွှင့်ရုံများ"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"အသုံးအများဆုံးများ"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-nb/strings.xml b/car-broadcastradio-support/res/values-nb/strings.xml
index 216e3bf..79544cb 100644
--- a/car-broadcastradio-support/res/values-nb/strings.xml
+++ b/car-broadcastradio-support/res/values-nb/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Stasjoner"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Favoritter"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-ne/strings.xml b/car-broadcastradio-support/res/values-ne/strings.xml
index 1428c68..ee1887b 100644
--- a/car-broadcastradio-support/res/values-ne/strings.xml
+++ b/car-broadcastradio-support/res/values-ne/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"पूर्वाह्न"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"एफएम"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"स्टेसनहरू"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"मन पर्ने कार्यक्रमहरू"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-nl/strings.xml b/car-broadcastradio-support/res/values-nl/strings.xml
index 07603ab..2f1a5e1 100644
--- a/car-broadcastradio-support/res/values-nl/strings.xml
+++ b/car-broadcastradio-support/res/values-nl/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Zenders"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Favorieten"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-or/strings.xml b/car-broadcastradio-support/res/values-or/strings.xml
index d3fda6c..2a149ad 100644
--- a/car-broadcastradio-support/res/values-or/strings.xml
+++ b/car-broadcastradio-support/res/values-or/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"ଷ୍ଟେଶନ୍"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"ପସନ୍ଦଦାର୍"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-pa/strings.xml b/car-broadcastradio-support/res/values-pa/strings.xml
index 1cee861..5f7ce46 100644
--- a/car-broadcastradio-support/res/values-pa/strings.xml
+++ b/car-broadcastradio-support/res/values-pa/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"ਸਟੇਸ਼ਨ"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"ਮਨਪਸੰਦ"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-pl/strings.xml b/car-broadcastradio-support/res/values-pl/strings.xml
index 7af82e4..1fc4d67 100644
--- a/car-broadcastradio-support/res/values-pl/strings.xml
+++ b/car-broadcastradio-support/res/values-pl/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Stacje"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Ulubione"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-pt-rPT/strings.xml b/car-broadcastradio-support/res/values-pt-rPT/strings.xml
index fad8527..a4b120a 100644
--- a/car-broadcastradio-support/res/values-pt-rPT/strings.xml
+++ b/car-broadcastradio-support/res/values-pt-rPT/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Estações"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Favoritas"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-pt/strings.xml b/car-broadcastradio-support/res/values-pt/strings.xml
index fd5f66a..9d72f03 100644
--- a/car-broadcastradio-support/res/values-pt/strings.xml
+++ b/car-broadcastradio-support/res/values-pt/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Estações"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Favoritos"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-ro/strings.xml b/car-broadcastradio-support/res/values-ro/strings.xml
index 6bde5d3..7ab0b50 100644
--- a/car-broadcastradio-support/res/values-ro/strings.xml
+++ b/car-broadcastradio-support/res/values-ro/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Posturi"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Preferate"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-ru/strings.xml b/car-broadcastradio-support/res/values-ru/strings.xml
index 01c21cd..2fed0f4 100644
--- a/car-broadcastradio-support/res/values-ru/strings.xml
+++ b/car-broadcastradio-support/res/values-ru/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"Цифровое радио"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Радиостанции"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Избранное"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-si/strings.xml b/car-broadcastradio-support/res/values-si/strings.xml
index 391d260..53f72c6 100644
--- a/car-broadcastradio-support/res/values-si/strings.xml
+++ b/car-broadcastradio-support/res/values-si/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"නාලිකා"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"ප්‍රියතම"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-sk/strings.xml b/car-broadcastradio-support/res/values-sk/strings.xml
index adf6e1a..fcdab92 100644
--- a/car-broadcastradio-support/res/values-sk/strings.xml
+++ b/car-broadcastradio-support/res/values-sk/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Stanice"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Obľúbené"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-sl/strings.xml b/car-broadcastradio-support/res/values-sl/strings.xml
index 2945e21..f0d3770 100644
--- a/car-broadcastradio-support/res/values-sl/strings.xml
+++ b/car-broadcastradio-support/res/values-sl/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Postaje"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Priljubljene"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-sq/strings.xml b/car-broadcastradio-support/res/values-sq/strings.xml
index 8f1b4d9..a4c1c95 100644
--- a/car-broadcastradio-support/res/values-sq/strings.xml
+++ b/car-broadcastradio-support/res/values-sq/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Stacionet"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Të preferuarat"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-sr/strings.xml b/car-broadcastradio-support/res/values-sr/strings.xml
index 523eda3..8321b8c 100644
--- a/car-broadcastradio-support/res/values-sr/strings.xml
+++ b/car-broadcastradio-support/res/values-sr/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Станице"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Омиљено"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-sv/strings.xml b/car-broadcastradio-support/res/values-sv/strings.xml
index c46fd0a..5475b03 100644
--- a/car-broadcastradio-support/res/values-sv/strings.xml
+++ b/car-broadcastradio-support/res/values-sv/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Kanaler"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Favoriter"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-sw/strings.xml b/car-broadcastradio-support/res/values-sw/strings.xml
index 159ec7f..879df73 100644
--- a/car-broadcastradio-support/res/values-sw/strings.xml
+++ b/car-broadcastradio-support/res/values-sw/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Stesheni"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Unavyopenda"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-ta/strings.xml b/car-broadcastradio-support/res/values-ta/strings.xml
index bf30aff..6b91b37 100644
--- a/car-broadcastradio-support/res/values-ta/strings.xml
+++ b/car-broadcastradio-support/res/values-ta/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"நிலையங்கள்"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"பிடித்தவை"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-te/strings.xml b/car-broadcastradio-support/res/values-te/strings.xml
index ca79c9e..864e222 100644
--- a/car-broadcastradio-support/res/values-te/strings.xml
+++ b/car-broadcastradio-support/res/values-te/strings.xml
@@ -17,7 +17,8 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
-    <string name="radio_fm_text" msgid="1973045042281933494">"ఎఫ్ఎమ్"</string>
+    <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"స్టేషన్‌లు"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"ఇష్టమైనవి"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-th/strings.xml b/car-broadcastradio-support/res/values-th/strings.xml
index fdd2f2e..0370e76 100644
--- a/car-broadcastradio-support/res/values-th/strings.xml
+++ b/car-broadcastradio-support/res/values-th/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"สถานี"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"รายการโปรด"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-tl/strings.xml b/car-broadcastradio-support/res/values-tl/strings.xml
index 91e39d9..932e133 100644
--- a/car-broadcastradio-support/res/values-tl/strings.xml
+++ b/car-broadcastradio-support/res/values-tl/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Mga Istasyon"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Mga Paborito"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-tr/strings.xml b/car-broadcastradio-support/res/values-tr/strings.xml
index 946664e..136387f 100644
--- a/car-broadcastradio-support/res/values-tr/strings.xml
+++ b/car-broadcastradio-support/res/values-tr/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"İstasyonlar"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Favoriler"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-uk/strings.xml b/car-broadcastradio-support/res/values-uk/strings.xml
index 47e213e..cdd259a 100644
--- a/car-broadcastradio-support/res/values-uk/strings.xml
+++ b/car-broadcastradio-support/res/values-uk/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Станції"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Вибране"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-ur/strings.xml b/car-broadcastradio-support/res/values-ur/strings.xml
index f670f1f..a511d89 100644
--- a/car-broadcastradio-support/res/values-ur/strings.xml
+++ b/car-broadcastradio-support/res/values-ur/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"اسٹیشنز"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"پسندیدہ"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-uz/strings.xml b/car-broadcastradio-support/res/values-uz/strings.xml
index ad615fb..5ff7a60 100644
--- a/car-broadcastradio-support/res/values-uz/strings.xml
+++ b/car-broadcastradio-support/res/values-uz/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"Raqamli radio"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Radiostansiyalar"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Saralanganlar"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-vi/strings.xml b/car-broadcastradio-support/res/values-vi/strings.xml
index 71d5556..067c179 100644
--- a/car-broadcastradio-support/res/values-vi/strings.xml
+++ b/car-broadcastradio-support/res/values-vi/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"Phát thanh kỹ thuật số"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Đài"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Đài yêu thích"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-zh-rCN/strings.xml b/car-broadcastradio-support/res/values-zh-rCN/strings.xml
index 2352240..1789a58 100644
--- a/car-broadcastradio-support/res/values-zh-rCN/strings.xml
+++ b/car-broadcastradio-support/res/values-zh-rCN/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"电台"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"收藏"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-zh-rHK/strings.xml b/car-broadcastradio-support/res/values-zh-rHK/strings.xml
index 25599bd..bb596c2 100644
--- a/car-broadcastradio-support/res/values-zh-rHK/strings.xml
+++ b/car-broadcastradio-support/res/values-zh-rHK/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"數碼聲音廣播"</string>
     <string name="program_list_text" msgid="4414150317304422313">"電台"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"收藏"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-zh-rTW/strings.xml b/car-broadcastradio-support/res/values-zh-rTW/strings.xml
index 25599bd..0ba44bc 100644
--- a/car-broadcastradio-support/res/values-zh-rTW/strings.xml
+++ b/car-broadcastradio-support/res/values-zh-rTW/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"電台"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"收藏"</string>
 </resources>
diff --git a/car-broadcastradio-support/res/values-zu/strings.xml b/car-broadcastradio-support/res/values-zu/strings.xml
index 441d3c7..dd5578b 100644
--- a/car-broadcastradio-support/res/values-zu/strings.xml
+++ b/car-broadcastradio-support/res/values-zu/strings.xml
@@ -18,6 +18,7 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="radio_am_text" msgid="571324921988967868">"AM"</string>
     <string name="radio_fm_text" msgid="1973045042281933494">"FM"</string>
+    <string name="radio_dab_text" msgid="8456449462266648979">"I-DAB"</string>
     <string name="program_list_text" msgid="4414150317304422313">"Iziteshi"</string>
     <string name="favorites_list_text" msgid="7829827713977109155">"Izintandokazi"</string>
 </resources>
diff --git a/car-chassis-lib/res/values-af/strings.xml b/car-chassis-lib/res/values-af/strings.xml
new file mode 100644
index 0000000..16285aa
--- /dev/null
+++ b/car-chassis-lib/res/values-af/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Soek …"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Rollees af"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Rollees op"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Soek"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Instellings"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"OK"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Kanselleer"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Aan"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Af"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-am/strings.xml b/car-chassis-lib/res/values-am/strings.xml
new file mode 100644
index 0000000..bd843de
--- /dev/null
+++ b/car-chassis-lib/res/values-am/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"ይፈልጉ…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"ወደ ታች ይሸብልሉ"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"ወደ ላይ ይሸብልሉ"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"ፈልግ"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"ቅንብሮች"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"እሺ"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"ይቅር"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"በርቷል"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"ጠፍቷል"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-ar/strings.xml b/car-chassis-lib/res/values-ar/strings.xml
new file mode 100644
index 0000000..6fa1bed
--- /dev/null
+++ b/car-chassis-lib/res/values-ar/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"بحث…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"التمرير للأسفل"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"التمرير للأعلى"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"بحث"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"الإعدادات"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"موافق"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"إلغاء"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"مفعّل"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"غير مفعّل"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-as/strings.xml b/car-chassis-lib/res/values-as/strings.xml
new file mode 100644
index 0000000..b1b7055
--- /dev/null
+++ b/car-chassis-lib/res/values-as/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"সন্ধান কৰক…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"তললৈ স্ক্ৰল কৰক"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"ওপৰলৈ স্ক্ৰল কৰক"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"সন্ধান কৰক"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"ছেটিংসমূহ"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"ঠিক আছে"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"বাতিল কৰক"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"অন আছে"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"অফ আছে"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-az/strings.xml b/car-chassis-lib/res/values-az/strings.xml
new file mode 100644
index 0000000..93c1067
--- /dev/null
+++ b/car-chassis-lib/res/values-az/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Axtarış…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Aşağı sürüşdürün"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Yuxarı sürüşdürün"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Axtarın"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Ayarlar"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"Ok"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Ləğv edin"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Aktiv"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Deaktiv"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-b+sr+Latn/strings.xml b/car-chassis-lib/res/values-b+sr+Latn/strings.xml
new file mode 100644
index 0000000..b5ce310
--- /dev/null
+++ b/car-chassis-lib/res/values-b+sr+Latn/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Pretražite…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Pomerite nadole"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Pomerite nagore"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Pretražite"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Podešavanja"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"Potvrdi"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Otkaži"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Uključeno"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Isključeno"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-be/strings.xml b/car-chassis-lib/res/values-be/strings.xml
new file mode 100644
index 0000000..11940cb
--- /dev/null
+++ b/car-chassis-lib/res/values-be/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Пошук…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Прагартаць уніз"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Прагартаць уверх"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Пошук"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Налады"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"ОК"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Скасаваць"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Уключана"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Выключана"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-bg/strings.xml b/car-chassis-lib/res/values-bg/strings.xml
new file mode 100644
index 0000000..ac060a4
--- /dev/null
+++ b/car-chassis-lib/res/values-bg/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Търсете…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Превъртане надолу"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Превъртане нагоре"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Търсене"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Настройки"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"OK"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Отказ"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Вкл."</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Изкл."</string>
+</resources>
diff --git a/car-chassis-lib/res/values-bn/strings.xml b/car-chassis-lib/res/values-bn/strings.xml
new file mode 100644
index 0000000..f2ed879
--- /dev/null
+++ b/car-chassis-lib/res/values-bn/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"সার্চ করুন…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"নিচে স্ক্রল করুন"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"উপরে স্ক্রল করুন"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"সার্চ করুন"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"সেটিংস"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"ঠিক আছে"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"বাতিল করুন"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"চালু আছে"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"বন্ধ আছে"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-bs/strings.xml b/car-chassis-lib/res/values-bs/strings.xml
new file mode 100644
index 0000000..4aacf32
--- /dev/null
+++ b/car-chassis-lib/res/values-bs/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Pretražite…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Klizni prema dolje"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Klizni prema gore"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Pretraži"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Postavke"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"Uredu"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Otkaži"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Uključeno"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Isključeno"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-ca/strings.xml b/car-chassis-lib/res/values-ca/strings.xml
new file mode 100644
index 0000000..3e78e9b
--- /dev/null
+++ b/car-chassis-lib/res/values-ca/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Cerca…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Desplaça cap avall"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Desplaça cap amunt"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Cerca"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Configuració"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"D\'acord"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Cancel·la"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Activat"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Desactivat"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-cs/strings.xml b/car-chassis-lib/res/values-cs/strings.xml
new file mode 100644
index 0000000..4c57eff
--- /dev/null
+++ b/car-chassis-lib/res/values-cs/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Vyhledat…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Posunout dolů"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Posunout nahoru"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Hledat"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Nastavení"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"OK"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Zrušit"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Zapnuto"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Vypnuto"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-da/strings.xml b/car-chassis-lib/res/values-da/strings.xml
new file mode 100644
index 0000000..5d2cf6e
--- /dev/null
+++ b/car-chassis-lib/res/values-da/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Søg…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Rul ned"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Rul op"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Søg"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Indstillinger"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"OK"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Annuller"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Til"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Fra"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-de/strings.xml b/car-chassis-lib/res/values-de/strings.xml
new file mode 100644
index 0000000..d23b3b0
--- /dev/null
+++ b/car-chassis-lib/res/values-de/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Suchen…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Nach unten scrollen"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Nach oben scrollen"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Suchen"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Einstellungen"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"OK"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Abbrechen"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"An"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Aus"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-el/strings.xml b/car-chassis-lib/res/values-el/strings.xml
new file mode 100644
index 0000000..9ee3a76
--- /dev/null
+++ b/car-chassis-lib/res/values-el/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Αναζήτηση…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Κύλιση προς τα κάτω"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Κύλιση προς τα επάνω"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Αναζήτηση"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Ρυθμίσεις"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"OK"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Ακύρωση"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Ενεργό"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Ανενεργό"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-en-rAU/strings.xml b/car-chassis-lib/res/values-en-rAU/strings.xml
new file mode 100644
index 0000000..4b4b48b
--- /dev/null
+++ b/car-chassis-lib/res/values-en-rAU/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Search…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Scroll down"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Scroll up"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Search"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Settings"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"OK"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Cancel"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"On"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Off"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-en-rCA/strings.xml b/car-chassis-lib/res/values-en-rCA/strings.xml
new file mode 100644
index 0000000..4b4b48b
--- /dev/null
+++ b/car-chassis-lib/res/values-en-rCA/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Search…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Scroll down"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Scroll up"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Search"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Settings"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"OK"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Cancel"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"On"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Off"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-en-rGB/strings.xml b/car-chassis-lib/res/values-en-rGB/strings.xml
new file mode 100644
index 0000000..4b4b48b
--- /dev/null
+++ b/car-chassis-lib/res/values-en-rGB/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Search…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Scroll down"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Scroll up"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Search"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Settings"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"OK"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Cancel"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"On"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Off"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-en-rIN/strings.xml b/car-chassis-lib/res/values-en-rIN/strings.xml
new file mode 100644
index 0000000..4b4b48b
--- /dev/null
+++ b/car-chassis-lib/res/values-en-rIN/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Search…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Scroll down"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Scroll up"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Search"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Settings"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"OK"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Cancel"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"On"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Off"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-en-rXC/strings.xml b/car-chassis-lib/res/values-en-rXC/strings.xml
new file mode 100644
index 0000000..75defb3
--- /dev/null
+++ b/car-chassis-lib/res/values-en-rXC/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‎‏‏‏‏‏‎‏‎‏‎‎‎‏‏‏‏‎‎‎‏‏‎‎‎‏‏‏‎‎‏‏‏‏‏‏‎‏‎‎‏‎‏‎‏‎‏‏‏‎‏‎‏‎‏‏‎‏‎‎‎‏‏‎Search…‎‏‎‎‏‎"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‎‎‏‏‎‏‎‏‎‎‏‏‎‎‏‏‎‎‏‎‏‏‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‏‏‏‎‏‎‎‏‏‎‏‎‎‎‏‎‎‎‏‏‏‎‏‎‎Scroll down‎‏‎‎‏‎"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‏‏‏‏‏‏‏‎‏‎‎‏‎‏‎‎‏‎‏‏‏‎‏‎‏‏‏‎‏‏‎‏‏‎‏‎‎‏‎‎‎‏‎‏‏‎‎‏‎‎‎‏‎‏‏‏‏‎‎‎‎‎‎‏‎‎Scroll up‎‏‎‎‏‎"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‏‏‏‏‏‎‏‎‎‎‎‏‎‏‎‏‏‎‎‏‎‏‏‎‏‎‎‎‏‎‏‎‏‏‎‏‏‏‎‏‎‏‎‎‎‏‎‎‏‎‏‎‎‏‎‎‎‎‎‏‏‎‏‎‎‎Search‎‏‎‎‏‎"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‎‏‏‏‎‏‏‎‏‏‏‎‏‏‏‏‏‎‏‎‎‎‏‎‏‏‎‏‏‏‎‏‎‎‎‏‎‏‎‎‎‏‏‏‎‏‎‎‏‎‏‏‏‏‏‎‎‏‏‏‎‏‏‎Settings‎‏‎‎‏‎"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‎‏‏‏‏‎‎‏‎‎‏‎‎‏‎‎‏‏‏‏‏‎‎‎‏‎‎‏‏‏‎‏‏‎‎‎‏‎‎‎‎‎‎‎‎‎‎‏‎‏‏‏‎‏‏‎‏‏‏‎‏‎‎Ok‎‏‎‎‏‎"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‏‏‏‎‎‏‏‎‏‎‏‎‎‏‏‎‏‏‏‏‏‏‎‎‏‏‎‎‏‏‏‏‎‎‏‎‏‏‏‎‏‏‎‏‏‏‏‏‏‎‎‏‏‎‎‎‏‎‏‎‎‎‎‎‎‎Cancel‎‏‎‎‏‎"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‎‏‏‏‎‏‎‎‎‏‎‏‎‏‎‏‎‎‎‏‏‏‎‎‎‏‎‎‎‏‏‎‎‎‎‏‎‏‏‏‏‎‏‏‎‏‎‏‎‏‏‎‎‏‎‎‏‎‏‏‎‎‏‎On‎‏‎‎‏‎"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‏‏‏‎‏‎‎‏‏‏‏‎‎‏‎‏‎‎‏‎‎‎‏‎‏‏‏‎‏‏‏‏‏‏‎‏‎‎‏‎‎‎‎‏‎‎‎‏‏‎‎‏‎‏‎‎‏‎‎‎‏‎‎‎‎‎Off‎‏‎‎‏‎"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-es-rUS/strings.xml b/car-chassis-lib/res/values-es-rUS/strings.xml
new file mode 100644
index 0000000..2e721e8
--- /dev/null
+++ b/car-chassis-lib/res/values-es-rUS/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Buscar…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Desplazarse hacia abajo"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Desplazarse hacia arriba"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Buscar"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Configuración"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"Aceptar"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Cancelar"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Sí"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"No"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-es/strings.xml b/car-chassis-lib/res/values-es/strings.xml
new file mode 100644
index 0000000..fceb60c
--- /dev/null
+++ b/car-chassis-lib/res/values-es/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Buscar…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Desplazarse hacia abajo"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Desplazarse hacia arriba"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Buscar"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Ajustes"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"Aceptar"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Cancelar"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Activado"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Desactivado"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-et/strings.xml b/car-chassis-lib/res/values-et/strings.xml
new file mode 100644
index 0000000..147bb04
--- /dev/null
+++ b/car-chassis-lib/res/values-et/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Otsing …"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Keri alla"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Keri üles"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Otsing"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Seaded"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"OK"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Tühista"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Sees"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Väljas"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-eu/strings.xml b/car-chassis-lib/res/values-eu/strings.xml
new file mode 100644
index 0000000..3d63364
--- /dev/null
+++ b/car-chassis-lib/res/values-eu/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Bilatu…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Egin behera"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Egin gora"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Bilatu"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Ezarpenak"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"Ados"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Utzi"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Aktibatuta"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Desaktibatuta"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-fa/strings.xml b/car-chassis-lib/res/values-fa/strings.xml
new file mode 100644
index 0000000..e55f253
--- /dev/null
+++ b/car-chassis-lib/res/values-fa/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"جستجو…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"پیمایش به پایین"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"پیمایش به بالا"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"جستجو"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"تنظیمات"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"تأیید"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"لغو"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"فعال"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"غیرفعال"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-fi/strings.xml b/car-chassis-lib/res/values-fi/strings.xml
new file mode 100644
index 0000000..0786887
--- /dev/null
+++ b/car-chassis-lib/res/values-fi/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Hae…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Vieritä alas"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Vieritä ylös"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Haku"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Asetukset"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"OK"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Peruuta"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Käytössä"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Ei käytössä"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-fr-rCA/strings.xml b/car-chassis-lib/res/values-fr-rCA/strings.xml
new file mode 100644
index 0000000..2561efa
--- /dev/null
+++ b/car-chassis-lib/res/values-fr-rCA/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Rechercher…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Faire défiler vers le bas"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Faire défiler vers le haut"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Rechercher"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Paramètres"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"OK"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Annuler"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Activées"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Désactivées"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-fr/strings.xml b/car-chassis-lib/res/values-fr/strings.xml
new file mode 100644
index 0000000..1ffdde4
--- /dev/null
+++ b/car-chassis-lib/res/values-fr/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Rechercher…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Faire défiler l\'écran vers bas"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Faire défiler l\'écran vers haut"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Rechercher"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Paramètres"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"OK"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Annuler"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Activé"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Désactivé"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-gl/strings.xml b/car-chassis-lib/res/values-gl/strings.xml
new file mode 100644
index 0000000..cb46421
--- /dev/null
+++ b/car-chassis-lib/res/values-gl/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Busca…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Desprazarse cara abaixo"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Desprazarse cara arriba"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Buscar"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Configuración"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"Aceptar"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Cancelar"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Activado"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Desactivado"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-gu/strings.xml b/car-chassis-lib/res/values-gu/strings.xml
new file mode 100644
index 0000000..45ea92d
--- /dev/null
+++ b/car-chassis-lib/res/values-gu/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"શોધો…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"નીચેની તરફ સ્ક્રોલ કરો"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"ઉપરની તરફ સ્ક્રોલ કરો"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"શોધ"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"સેટિંગ"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"ઓકે"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"રદ કરો"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"ચાલુ"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"બંધ"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-hi/strings.xml b/car-chassis-lib/res/values-hi/strings.xml
new file mode 100644
index 0000000..ccfacef
--- /dev/null
+++ b/car-chassis-lib/res/values-hi/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"खोजें…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"नीचे की ओर स्क्रोल करें"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"ऊपर की ओर स्क्रोल करें"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"खोजें"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"सेटिंग"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"ठीक है"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"रद्द करें"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"चालू है"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"बंद है"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-hr/strings.xml b/car-chassis-lib/res/values-hr/strings.xml
new file mode 100644
index 0000000..dec5832
--- /dev/null
+++ b/car-chassis-lib/res/values-hr/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Pretražite…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Pomakni prema dolje"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Pomakni prema gore"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Pretraži"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Postavke"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"U redu"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Odustani"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Uključeno"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Isključeno"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-hu/strings.xml b/car-chassis-lib/res/values-hu/strings.xml
new file mode 100644
index 0000000..2234528
--- /dev/null
+++ b/car-chassis-lib/res/values-hu/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Keresés…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Görgetés lefelé"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Görgetés felfelé"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Keresés"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Beállítások"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"OK"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Mégse"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Be"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Ki"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-hy/strings.xml b/car-chassis-lib/res/values-hy/strings.xml
new file mode 100644
index 0000000..a1e78f2
--- /dev/null
+++ b/car-chassis-lib/res/values-hy/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Որոնում…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Ոլորել վար"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Ոլորել վեր"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Որոնում"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Կարգավորումներ"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"Եղավ"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Չեղարկել"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Միացված է"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Անջատված է"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-in/strings.xml b/car-chassis-lib/res/values-in/strings.xml
new file mode 100644
index 0000000..4f7f83b
--- /dev/null
+++ b/car-chassis-lib/res/values-in/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Telusuri…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Scroll ke bawah"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Scroll ke atas"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Telusuri"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Setelan"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"Oke"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Batal"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Aktif"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Nonaktif"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-is/strings.xml b/car-chassis-lib/res/values-is/strings.xml
new file mode 100644
index 0000000..1bf724f
--- /dev/null
+++ b/car-chassis-lib/res/values-is/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Leita…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Fletta niður"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Fletta upp"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Leit"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Stillingar"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"Í lagi"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Hætta við"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Kveikt"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Slökkt"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-it/strings.xml b/car-chassis-lib/res/values-it/strings.xml
new file mode 100644
index 0000000..9c1cb1f
--- /dev/null
+++ b/car-chassis-lib/res/values-it/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Cerca…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Scorri verso il basso"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Scorri verso l\'alto"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Cerca"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Impostazioni"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"OK"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Annulla"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"On"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Off"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-iw/strings.xml b/car-chassis-lib/res/values-iw/strings.xml
new file mode 100644
index 0000000..1b6d0df
--- /dev/null
+++ b/car-chassis-lib/res/values-iw/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"חיפוש…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"גלילה למטה"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"גלילה למעלה"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"חיפוש"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"הגדרות"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"אישור"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"ביטול"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"מופעל"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"כבוי"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-ja/strings.xml b/car-chassis-lib/res/values-ja/strings.xml
new file mode 100644
index 0000000..d3bdfc0
--- /dev/null
+++ b/car-chassis-lib/res/values-ja/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"検索…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"下にスクロール"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"上にスクロール"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"検索"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"設定"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"OK"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"キャンセル"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"ON"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"OFF"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-ka/strings.xml b/car-chassis-lib/res/values-ka/strings.xml
new file mode 100644
index 0000000..8382513
--- /dev/null
+++ b/car-chassis-lib/res/values-ka/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"ძიება…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"ქვემოთ გადაადგილება"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"ზემოთ გადაადგილება"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"ძიება"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"პარამეტრები"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"კარგი"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"გაუქმება"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"ჩართულია"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"გამორთულია"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-kk/strings.xml b/car-chassis-lib/res/values-kk/strings.xml
new file mode 100644
index 0000000..76b5f0a
--- /dev/null
+++ b/car-chassis-lib/res/values-kk/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Іздеу…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Төмен қарай айналдыру"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Жоғары қарай айналдыру"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Іздеу"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Параметрлер"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"Жарайды"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Бас тарту"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Қосулы"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Өшірулі"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-km/strings.xml b/car-chassis-lib/res/values-km/strings.xml
new file mode 100644
index 0000000..136cb74
--- /dev/null
+++ b/car-chassis-lib/res/values-km/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"ស្វែងរក…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"រំកិលចុះក្រោម"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"រំកិល​​ឡើង​លើ"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"ស្វែងរក"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"ការកំណត់"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"យល់ព្រម"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"បោះបង់"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"បើក"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"បិទ"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-kn/strings.xml b/car-chassis-lib/res/values-kn/strings.xml
new file mode 100644
index 0000000..5ebfab4
--- /dev/null
+++ b/car-chassis-lib/res/values-kn/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"ಹುಡುಕಿ…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"ಕೆಳಗೆ ಸ್ಕ್ರಾಲ್ ಮಾಡಿ"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"ಮೇಲೆ ಸ್ಕ್ರಾಲ್ ಮಾಡಿ"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"ಹುಡುಕಿ"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"ಸೆಟ್ಟಿಂಗ್‌ಗಳು"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"ಸರಿ"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"ರದ್ದುಮಾಡಿ"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"ಆನ್ ಆಗಿದೆ"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"ಆಫ್ ಆಗಿದೆ"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-ko/strings.xml b/car-chassis-lib/res/values-ko/strings.xml
new file mode 100644
index 0000000..f324b1e
--- /dev/null
+++ b/car-chassis-lib/res/values-ko/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"검색…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"아래로 스크롤"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"위로 스크롤"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"검색"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"설정"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"확인"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"취소"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"사용 설정됨"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"사용 중지됨"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-ky/strings.xml b/car-chassis-lib/res/values-ky/strings.xml
new file mode 100644
index 0000000..f05a6cc
--- /dev/null
+++ b/car-chassis-lib/res/values-ky/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Издөө…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Төмөн сыдыруу"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Жогору сыдыруу"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Издөө"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Жөндөөлөр"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"Жарайт"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Жокко чыгаруу"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Күйүк"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Өчүк"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-lo/strings.xml b/car-chassis-lib/res/values-lo/strings.xml
new file mode 100644
index 0000000..2404818
--- /dev/null
+++ b/car-chassis-lib/res/values-lo/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"ຊອກຫາ…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"ເລື່ອນລົງ"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"ເລື່ອນຂຶ້ນ"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"ຊອກຫາ"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"ການຕັ້ງຄ່າ"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"ຕົກລົງ"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"ຍົກເລີກ"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"ເປີດ"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"ປິດ"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-lt/strings.xml b/car-chassis-lib/res/values-lt/strings.xml
new file mode 100644
index 0000000..25b0b09
--- /dev/null
+++ b/car-chassis-lib/res/values-lt/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Ieškoti…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Slinkti žemyn"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Slinkti aukštyn"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Paieška"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Nustatymai"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"Gerai"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Atšaukti"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Įjungta"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Išjungta"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-lv/strings.xml b/car-chassis-lib/res/values-lv/strings.xml
new file mode 100644
index 0000000..0fd6da7
--- /dev/null
+++ b/car-chassis-lib/res/values-lv/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Meklēt…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Ritināt uz leju"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Ritināt uz augšu"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Meklēt"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Iestatījumi"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"Labi"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Atcelt"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Ieslēgts"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Izslēgts"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-mk/strings.xml b/car-chassis-lib/res/values-mk/strings.xml
new file mode 100644
index 0000000..014279a
--- /dev/null
+++ b/car-chassis-lib/res/values-mk/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Пребарувајте…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Лизгај надолу"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Лизгај нагоре"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Пребарувајте"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Поставки"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"Во ред"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Откажи"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Вклученo"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Исклученo"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-ml/strings.xml b/car-chassis-lib/res/values-ml/strings.xml
new file mode 100644
index 0000000..e417c6e
--- /dev/null
+++ b/car-chassis-lib/res/values-ml/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"തിരയുക…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"താഴോട്ട് സ്‌ക്രോൾ ചെയ്യുക"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"മുകളിലോട്ട് സ്‌ക്രോൾ ചെയ്യുക"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"തിരയുക"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"ക്രമീകരണം"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"ശരി"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"റദ്ദാക്കുക"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"ഓണാക്കുക"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"ഓഫാക്കുക"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-mn/strings.xml b/car-chassis-lib/res/values-mn/strings.xml
new file mode 100644
index 0000000..24cff6f
--- /dev/null
+++ b/car-chassis-lib/res/values-mn/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Хайх…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Доош гүйлгэх"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Дээш гүйлгэх"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Хайлт"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Тохиргоо"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"Ок"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Цуцлах"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Асаалттай"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Унтраалттай"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-mr/strings.xml b/car-chassis-lib/res/values-mr/strings.xml
new file mode 100644
index 0000000..e371f8d
--- /dev/null
+++ b/car-chassis-lib/res/values-mr/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"शोधा…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"खाली स्क्रोल करा"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"वर स्क्रोल करा"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"शोधा"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"सेटिंग्ज"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"ओके"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"रद्द करा"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"सुरू आहे"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"बंद आहे"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-ms/strings.xml b/car-chassis-lib/res/values-ms/strings.xml
new file mode 100644
index 0000000..14ce3b2
--- /dev/null
+++ b/car-chassis-lib/res/values-ms/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Cari…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Tatal ke bawah"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Tatal ke atas"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Cari"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Tetapan"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"Ok"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Batal"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Hidup"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Mati"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-my/strings.xml b/car-chassis-lib/res/values-my/strings.xml
new file mode 100644
index 0000000..20b19d8
--- /dev/null
+++ b/car-chassis-lib/res/values-my/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"ရှာဖွေရန်…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"အောက်သို့ လှိမ့်ရန်"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"အပေါ်သို့ လှိမ့်ရန်"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"ရှာဖွေခြင်း"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"ဆက်တင်များ"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"OK"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"မလုပ်တော့"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"ဖွင့်ထားသည်"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"ပိတ်ထားသည်"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-nb/strings.xml b/car-chassis-lib/res/values-nb/strings.xml
new file mode 100644
index 0000000..ef1b909
--- /dev/null
+++ b/car-chassis-lib/res/values-nb/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Søk"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Rull ned"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Rull opp"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Søk"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Innstillinger"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"OK"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Avbryt"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"På"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Av"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-ne/strings.xml b/car-chassis-lib/res/values-ne/strings.xml
new file mode 100644
index 0000000..6ef6ff1
--- /dev/null
+++ b/car-chassis-lib/res/values-ne/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"खोज्नुहोस्…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"तलतिर स्क्रोल गर्नुहोस्"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"माथितिर स्क्रोल गर्नुहोस्"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"खोज्नुहोस्"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"सेटिङ"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"ठिक छ"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"रद्द गर्नुहोस्"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"सक्रिय"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"निष्क्रिय"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-nl/strings.xml b/car-chassis-lib/res/values-nl/strings.xml
new file mode 100644
index 0000000..711cceb
--- /dev/null
+++ b/car-chassis-lib/res/values-nl/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Zoeken…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Omlaag scrollen"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Omhoog scrollen"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Zoeken"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Instellingen"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"OK"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Annuleren"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Aan"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Uit"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-or/strings.xml b/car-chassis-lib/res/values-or/strings.xml
new file mode 100644
index 0000000..1fa7e16
--- /dev/null
+++ b/car-chassis-lib/res/values-or/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"ସନ୍ଧାନ କରନ୍ତୁ…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"ତଳକୁ ସ୍କ୍ରୋଲ୍ କରନ୍ତୁ"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"ଉପରକୁ ସ୍କ୍ରୋଲ୍ କରନ୍ତୁ"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"ସନ୍ଧାନ କରନ୍ତୁ"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"ସେଟିଂସ୍"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"ଠିକ୍ ଅଛି"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"ବାତିଲ୍ କରନ୍ତୁ"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"ଚାଲୁ ଅଛି"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"ବନ୍ଦ ଅଛି"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-pa/strings.xml b/car-chassis-lib/res/values-pa/strings.xml
new file mode 100644
index 0000000..1044ac3
--- /dev/null
+++ b/car-chassis-lib/res/values-pa/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"ਖੋਜੋ…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"ਹੇਠਾਂ ਵੱਲ ਸਕ੍ਰੋਲ ਕਰੋ"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"ਉੱਪਰ ਵੱਲ ਸਕ੍ਰੋਲ ਕਰੋ"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"ਖੋਜੋ"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"ਸੈਟਿੰਗਾਂ"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"ਠੀਕ ਹੈ"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"ਰੱਦ ਕਰੋ"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"ਚਾਲੂ"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"ਬੰਦ ਕਰੋ"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-pl/strings.xml b/car-chassis-lib/res/values-pl/strings.xml
new file mode 100644
index 0000000..54514db
--- /dev/null
+++ b/car-chassis-lib/res/values-pl/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Szukaj…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Przewiń w dół"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Przewiń w górę"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Szukaj"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Ustawienia"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"OK"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Anuluj"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Wł."</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Wył."</string>
+</resources>
diff --git a/car-chassis-lib/res/values-pt-rPT/strings.xml b/car-chassis-lib/res/values-pt-rPT/strings.xml
new file mode 100644
index 0000000..104c9ec
--- /dev/null
+++ b/car-chassis-lib/res/values-pt-rPT/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Pesquisar…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Deslocar para baixo"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Deslocar para cima"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Pesquisar"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Definições"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"OK"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Cancelar"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Ativado"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Desativado"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-pt/strings.xml b/car-chassis-lib/res/values-pt/strings.xml
new file mode 100644
index 0000000..524a4dc
--- /dev/null
+++ b/car-chassis-lib/res/values-pt/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Pesquisar…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Rolar para baixo"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Rolar para cima"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Pesquisar"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Configurações"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"Ok"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Cancelar"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Ativado"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Desativado"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-ro/strings.xml b/car-chassis-lib/res/values-ro/strings.xml
new file mode 100644
index 0000000..19b0a67
--- /dev/null
+++ b/car-chassis-lib/res/values-ro/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Căutați…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Derulați în jos"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Derulați în sus"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Căutați"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Setări"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"OK"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Anulați"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Activat"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Dezactivat"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-ru/strings.xml b/car-chassis-lib/res/values-ru/strings.xml
new file mode 100644
index 0000000..3794d18
--- /dev/null
+++ b/car-chassis-lib/res/values-ru/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Введите запрос"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Прокрутить вниз"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Прокрутить вверх"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Поиск"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Настройки"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"ОК"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Отмена"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Включено"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Отключено"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-si/strings.xml b/car-chassis-lib/res/values-si/strings.xml
new file mode 100644
index 0000000..5902ccc
--- /dev/null
+++ b/car-chassis-lib/res/values-si/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"සොයන්න…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"පහළට අනුචලනය කරන්න"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"ඉහළට අනුචලනය කරන්න"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"සොයන්න"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"සැකසීම්"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"හරි"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"අවලංගු කරන්න"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"ක්‍රියාත්මකයි"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"ක්‍රියාවිරහිතයි"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-sk/strings.xml b/car-chassis-lib/res/values-sk/strings.xml
new file mode 100644
index 0000000..9ef378f
--- /dev/null
+++ b/car-chassis-lib/res/values-sk/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Vyhľadať…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Posunúť nadol"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Posunúť nahor"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Hľadať"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Nastavenia"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"Ok"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Zrušiť"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Zapnuté"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Vypnuté"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-sl/strings.xml b/car-chassis-lib/res/values-sl/strings.xml
new file mode 100644
index 0000000..9a14270
--- /dev/null
+++ b/car-chassis-lib/res/values-sl/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Iskanje …"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Pomik navzdol"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Pomik navzgor"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Iskanje"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Nastavitve"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"V redu"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Prekliči"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Vklopljeno"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Izklopljeno"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-sq/strings.xml b/car-chassis-lib/res/values-sq/strings.xml
new file mode 100644
index 0000000..6034214
--- /dev/null
+++ b/car-chassis-lib/res/values-sq/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Kërko…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Lëviz poshtë"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Lëviz lart"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Kërko"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Cilësimet"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"Në rregull"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Anulo"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Aktiv"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Joaktiv"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-sr/strings.xml b/car-chassis-lib/res/values-sr/strings.xml
new file mode 100644
index 0000000..5478104
--- /dev/null
+++ b/car-chassis-lib/res/values-sr/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Претражите…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Померите надоле"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Померите нагоре"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Претражите"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Подешавања"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"Потврди"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Откажи"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Укључено"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Искључено"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-sv/strings.xml b/car-chassis-lib/res/values-sv/strings.xml
new file mode 100644
index 0000000..104379a
--- /dev/null
+++ b/car-chassis-lib/res/values-sv/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Sök …"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Skrolla nedåt"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Skrolla uppåt"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Sök"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Inställningar"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"OK"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Avbryt"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"På"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Av"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-sw/strings.xml b/car-chassis-lib/res/values-sw/strings.xml
new file mode 100644
index 0000000..1de3656
--- /dev/null
+++ b/car-chassis-lib/res/values-sw/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Tafuta…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Nenda chini"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Nenda juu"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Tafuta"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Mipangilio"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"Sawa"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Ghairi"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Imewashwa"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Imezimwa"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-ta/strings.xml b/car-chassis-lib/res/values-ta/strings.xml
new file mode 100644
index 0000000..75721a1
--- /dev/null
+++ b/car-chassis-lib/res/values-ta/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"தேடுக…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"கீழே செல்லும்"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"மேலே செல்லும்"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"தேடுக"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"அமைப்புகள்"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"சரி"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"ரத்துசெய்"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"ஆன்"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"ஆஃப்"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-te/strings.xml b/car-chassis-lib/res/values-te/strings.xml
new file mode 100644
index 0000000..c029b63
--- /dev/null
+++ b/car-chassis-lib/res/values-te/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"వెతకండి…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"కిందకు స్క్రోల్ చేయి"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"పైకి స్క్రోల్ చేయి"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"వెతుకు"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"సెట్టింగ్‌లు"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"సరే"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"రద్దు చేయి"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"ఆన్"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"ఆఫ్"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-th/strings.xml b/car-chassis-lib/res/values-th/strings.xml
new file mode 100644
index 0000000..7126a4b
--- /dev/null
+++ b/car-chassis-lib/res/values-th/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"ค้นหา…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"เลื่อนลง"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"เลื่อนขึ้น"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"ค้นหา"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"การตั้งค่า"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"ตกลง"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"ยกเลิก"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"เปิด"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"ปิด"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-tl/strings.xml b/car-chassis-lib/res/values-tl/strings.xml
new file mode 100644
index 0000000..d26911b
--- /dev/null
+++ b/car-chassis-lib/res/values-tl/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Maghanap…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Mag-scroll pababa"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Mag-scroll pataas"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Maghanap"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Mga Setting"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"Ok"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Kanselahin"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Naka-on"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Naka-off"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-tr/strings.xml b/car-chassis-lib/res/values-tr/strings.xml
new file mode 100644
index 0000000..64f8ffd
--- /dev/null
+++ b/car-chassis-lib/res/values-tr/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Ara…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Aşağı kaydır"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Yukarı kaydır"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Arama"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Ayarlar"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"Tamam"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"İptal et"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Açık"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Kapalı"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-uk/strings.xml b/car-chassis-lib/res/values-uk/strings.xml
new file mode 100644
index 0000000..559ae8d
--- /dev/null
+++ b/car-chassis-lib/res/values-uk/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Введіть пошуковий запит…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Прокрутити вниз"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Прокрутити вгору"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Пошук"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Налаштування"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"OK"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Скасувати"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Увімкнено"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Вимкнено"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-ur/strings.xml b/car-chassis-lib/res/values-ur/strings.xml
new file mode 100644
index 0000000..a16dff3
--- /dev/null
+++ b/car-chassis-lib/res/values-ur/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"تلاش کریں…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"نیچے اسکرول کریں"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"اوپر اسکرول کریں"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"تلاش کریں"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"ترتیبات"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"ٹھیک ہے"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"منسوخ کریں"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"آن ہے"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"آف ہے"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-uz/strings.xml b/car-chassis-lib/res/values-uz/strings.xml
new file mode 100644
index 0000000..5f52544
--- /dev/null
+++ b/car-chassis-lib/res/values-uz/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Qidirish…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Pastga tushish"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Tepaga chiqish"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Qidiruv"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Sozlamalar"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"Ok"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Bekor qilish"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Yoniq"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Yoqilmagan"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-vi/strings.xml b/car-chassis-lib/res/values-vi/strings.xml
new file mode 100644
index 0000000..161f777
--- /dev/null
+++ b/car-chassis-lib/res/values-vi/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Tìm kiếm…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Cuộn xuống"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Cuộn lên"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Tìm kiếm"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Cài đặt"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"Ok"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Hủy"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Đang bật"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Đang tắt"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-zh-rCN/strings.xml b/car-chassis-lib/res/values-zh-rCN/strings.xml
new file mode 100644
index 0000000..fa4360d
--- /dev/null
+++ b/car-chassis-lib/res/values-zh-rCN/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"搜索…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"向下滚动"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"向上滚动"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"搜索"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"设置"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"确定"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"取消"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"开启"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"关闭"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-zh-rHK/strings.xml b/car-chassis-lib/res/values-zh-rHK/strings.xml
new file mode 100644
index 0000000..57b5d6e
--- /dev/null
+++ b/car-chassis-lib/res/values-zh-rHK/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"搜尋…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"向下捲動"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"向上捲動"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"搜尋"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"設定"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"確定"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"取消"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"已開啟"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"已關閉"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-zh-rTW/strings.xml b/car-chassis-lib/res/values-zh-rTW/strings.xml
new file mode 100644
index 0000000..3c5c667
--- /dev/null
+++ b/car-chassis-lib/res/values-zh-rTW/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"搜尋…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"向下捲動"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"向上捲動"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"搜尋"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"設定"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"確定"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"取消"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"開啟"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"關閉"</string>
+</resources>
diff --git a/car-chassis-lib/res/values-zu/strings.xml b/car-chassis-lib/res/values-zu/strings.xml
new file mode 100644
index 0000000..120174f
--- /dev/null
+++ b/car-chassis-lib/res/values-zu/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="car_ui_toolbar_default_search_hint" msgid="2207826194657039779">"Sesha…"</string>
+    <string name="car_ui_scrollbar_page_down_button" msgid="958364812174795322">"Skrolela phansi"</string>
+    <string name="car_ui_scrollbar_page_up_button" msgid="9018869313464053506">"Skrolela phezulu"</string>
+    <string name="car_ui_toolbar_menu_item_search_title" msgid="8370833903745321012">"Sesha"</string>
+    <string name="car_ui_toolbar_menu_item_settings_title" msgid="1979280833948311355">"Izilungiselelo"</string>
+    <string name="car_ui_dialog_preference_positive" msgid="452961576396283322">"Kulungile"</string>
+    <string name="car_ui_dialog_preference_negative" msgid="5570382772700131648">"Khansela"</string>
+    <string name="car_ui_switch_preference_on" msgid="1885475675181855321">"Vuliwe"</string>
+    <string name="car_ui_switch_preference_off" msgid="6037715077277362448">"Valiwe"</string>
+</resources>
diff --git a/car-media-common/res/values-af/strings.xml b/car-media-common/res/values-af/strings.xml
index f75b467..c4efced 100644
--- a/car-media-common/res/values-af/strings.xml
+++ b/car-media-common/res/values-af/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Albumkunswerk"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Titelloos"</string>
 </resources>
diff --git a/car-media-common/res/values-am/strings.xml b/car-media-common/res/values-am/strings.xml
index 607ab45..9888274 100644
--- a/car-media-common/res/values-am/strings.xml
+++ b/car-media-common/res/values-am/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"የአልበም ስነ ጥበብ"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"ርዕስ የለም"</string>
 </resources>
diff --git a/car-media-common/res/values-ar/strings.xml b/car-media-common/res/values-ar/strings.xml
index d7a9a2c..609709e 100644
--- a/car-media-common/res/values-ar/strings.xml
+++ b/car-media-common/res/values-ar/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"صورة الألبوم"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"بلا عنوان"</string>
 </resources>
diff --git a/car-media-common/res/values-as/strings.xml b/car-media-common/res/values-as/strings.xml
index 3bdbf06..1513a5e 100644
--- a/car-media-common/res/values-as/strings.xml
+++ b/car-media-common/res/values-as/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"এলবাম আৰ্ট"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"কোনো শিৰোনাম নাই"</string>
 </resources>
diff --git a/car-media-common/res/values-az/strings.xml b/car-media-common/res/values-az/strings.xml
index 936d945..9e8a836 100644
--- a/car-media-common/res/values-az/strings.xml
+++ b/car-media-common/res/values-az/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Albom təsviri"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Başlıq yoxdur"</string>
 </resources>
diff --git a/car-media-common/res/values-b+sr+Latn/strings.xml b/car-media-common/res/values-b+sr+Latn/strings.xml
index 95bcfcc..60ea824 100644
--- a/car-media-common/res/values-b+sr+Latn/strings.xml
+++ b/car-media-common/res/values-b+sr+Latn/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Omot albuma"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Bez naslova"</string>
 </resources>
diff --git a/car-media-common/res/values-be/strings.xml b/car-media-common/res/values-be/strings.xml
index a1ddf1d..4a98eab 100644
--- a/car-media-common/res/values-be/strings.xml
+++ b/car-media-common/res/values-be/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Вокладка альбома"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Без назвы"</string>
 </resources>
diff --git a/car-media-common/res/values-bg/strings.xml b/car-media-common/res/values-bg/strings.xml
index 3895155..f595ed8 100644
--- a/car-media-common/res/values-bg/strings.xml
+++ b/car-media-common/res/values-bg/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Обложка на албума"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Няма заглавие"</string>
 </resources>
diff --git a/car-media-common/res/values-bn/strings.xml b/car-media-common/res/values-bn/strings.xml
index 3fbbaa0..c7366d7 100644
--- a/car-media-common/res/values-bn/strings.xml
+++ b/car-media-common/res/values-bn/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"অ্যালবাম আর্ট"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"কোনও শীর্ষক নেই"</string>
 </resources>
diff --git a/car-media-common/res/values-bs/strings.xml b/car-media-common/res/values-bs/strings.xml
index 95bcfcc..60ea824 100644
--- a/car-media-common/res/values-bs/strings.xml
+++ b/car-media-common/res/values-bs/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Omot albuma"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Bez naslova"</string>
 </resources>
diff --git a/car-media-common/res/values-ca/strings.xml b/car-media-common/res/values-ca/strings.xml
index 6f5c30c..c672d9b 100644
--- a/car-media-common/res/values-ca/strings.xml
+++ b/car-media-common/res/values-ca/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Imatge de l\'àlbum"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Sense títol"</string>
 </resources>
diff --git a/car-media-common/res/values-cs/strings.xml b/car-media-common/res/values-cs/strings.xml
index 9609baf..dfcffe0 100644
--- a/car-media-common/res/values-cs/strings.xml
+++ b/car-media-common/res/values-cs/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Obal alba"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Bez názvu"</string>
 </resources>
diff --git a/car-media-common/res/values-da/strings.xml b/car-media-common/res/values-da/strings.xml
index e62c850..1640516 100644
--- a/car-media-common/res/values-da/strings.xml
+++ b/car-media-common/res/values-da/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Albumgrafik"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Ingen titel"</string>
 </resources>
diff --git a/car-media-common/res/values-de/strings.xml b/car-media-common/res/values-de/strings.xml
index abec36e..7bafae6 100644
--- a/car-media-common/res/values-de/strings.xml
+++ b/car-media-common/res/values-de/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Albumcover"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Kein Titel"</string>
 </resources>
diff --git a/car-media-common/res/values-el/strings.xml b/car-media-common/res/values-el/strings.xml
index 99c9846..0b5de6d 100644
--- a/car-media-common/res/values-el/strings.xml
+++ b/car-media-common/res/values-el/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Εξώφυλλο άλμπουμ"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Χωρίς τίτλο"</string>
 </resources>
diff --git a/car-media-common/res/values-en-rAU/strings.xml b/car-media-common/res/values-en-rAU/strings.xml
index c2f2ef5..98e3148 100644
--- a/car-media-common/res/values-en-rAU/strings.xml
+++ b/car-media-common/res/values-en-rAU/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Album Art"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"No title"</string>
 </resources>
diff --git a/car-media-common/res/values-en-rCA/strings.xml b/car-media-common/res/values-en-rCA/strings.xml
index c2f2ef5..98e3148 100644
--- a/car-media-common/res/values-en-rCA/strings.xml
+++ b/car-media-common/res/values-en-rCA/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Album Art"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"No title"</string>
 </resources>
diff --git a/car-media-common/res/values-en-rGB/strings.xml b/car-media-common/res/values-en-rGB/strings.xml
index c2f2ef5..98e3148 100644
--- a/car-media-common/res/values-en-rGB/strings.xml
+++ b/car-media-common/res/values-en-rGB/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Album Art"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"No title"</string>
 </resources>
diff --git a/car-media-common/res/values-en-rIN/strings.xml b/car-media-common/res/values-en-rIN/strings.xml
index c2f2ef5..98e3148 100644
--- a/car-media-common/res/values-en-rIN/strings.xml
+++ b/car-media-common/res/values-en-rIN/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Album Art"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"No title"</string>
 </resources>
diff --git a/car-media-common/res/values-en-rXC/strings.xml b/car-media-common/res/values-en-rXC/strings.xml
index 16ae5ca..ecdf930 100644
--- a/car-media-common/res/values-en-rXC/strings.xml
+++ b/car-media-common/res/values-en-rXC/strings.xml
@@ -17,5 +17,6 @@
 
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="album_art" msgid="3392647029019061691">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‏‎‏‎‏‏‏‏‎‎‎‏‎‏‎‏‎‎‎‏‏‎‏‎‎‏‏‏‏‏‏‏‎‏‏‏‎‏‎‎‏‏‏‏‎‏‏‏‎‎‏‎‏‏‎‏‏‎‏‏‏‎‏‏‎Album Art‎‏‎‎‏‎"</string>
+    <string name="album_art" msgid="3392647029019061691">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‏‎‏‎‏‏‏‏‎‎‎‏‎‏‎‏‎‎‎‏‏‎‏‎‎‏‏‏‏‏‏‏‎‏‏‏‎‏‎‎‏‏‏‏‎‏‏‏‎‎‏‎‏‏‎‏‏‎‏‏‏‎‏‏‎Album Art‎‏‎‎‏‎"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‏‏‏‎‏‎‎‎‏‏‏‏‎‏‎‏‎‏‏‎‏‏‏‏‏‎‏‎‎‎‎‎‏‎‎‎‏‎‏‏‏‎‏‏‎‏‏‎‎‏‎‏‏‎‏‏‎‎‎‎‏‏‎‎‏‎No Title‎‏‎‎‏‎"</string>
 </resources>
diff --git a/car-media-common/res/values-es-rUS/strings.xml b/car-media-common/res/values-es-rUS/strings.xml
index 7faa6a0..18ba657 100644
--- a/car-media-common/res/values-es-rUS/strings.xml
+++ b/car-media-common/res/values-es-rUS/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Imagen del álbum"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Sin título"</string>
 </resources>
diff --git a/car-media-common/res/values-es/strings.xml b/car-media-common/res/values-es/strings.xml
index 7faa6a0..18ba657 100644
--- a/car-media-common/res/values-es/strings.xml
+++ b/car-media-common/res/values-es/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Imagen del álbum"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Sin título"</string>
 </resources>
diff --git a/car-media-common/res/values-et/strings.xml b/car-media-common/res/values-et/strings.xml
index e30d919..8ca4cf2 100644
--- a/car-media-common/res/values-et/strings.xml
+++ b/car-media-common/res/values-et/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Albumi kujundus"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Pealkiri puudub"</string>
 </resources>
diff --git a/car-media-common/res/values-eu/strings.xml b/car-media-common/res/values-eu/strings.xml
index 6d836b1..896aa2c 100644
--- a/car-media-common/res/values-eu/strings.xml
+++ b/car-media-common/res/values-eu/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Albumaren azala"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Izenik gabea"</string>
 </resources>
diff --git a/car-media-common/res/values-fa/strings.xml b/car-media-common/res/values-fa/strings.xml
index 5daf357..24bac8e 100644
--- a/car-media-common/res/values-fa/strings.xml
+++ b/car-media-common/res/values-fa/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"عکس روی جلد آلبوم"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"بدون عنوان"</string>
 </resources>
diff --git a/car-media-common/res/values-fi/strings.xml b/car-media-common/res/values-fi/strings.xml
index 545bb78..0fcaaf5 100644
--- a/car-media-common/res/values-fi/strings.xml
+++ b/car-media-common/res/values-fi/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Albumin kansitaide"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Ei nimeä"</string>
 </resources>
diff --git a/car-media-common/res/values-fr-rCA/strings.xml b/car-media-common/res/values-fr-rCA/strings.xml
index ac3abaf..66e06e1 100644
--- a/car-media-common/res/values-fr-rCA/strings.xml
+++ b/car-media-common/res/values-fr-rCA/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Image de l\'album"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Aucun titre"</string>
 </resources>
diff --git a/car-media-common/res/values-fr/strings.xml b/car-media-common/res/values-fr/strings.xml
index ac3abaf..dfbc082 100644
--- a/car-media-common/res/values-fr/strings.xml
+++ b/car-media-common/res/values-fr/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Image de l\'album"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Sans titre"</string>
 </resources>
diff --git a/car-media-common/res/values-gl/strings.xml b/car-media-common/res/values-gl/strings.xml
index 4e3b599..6971016 100644
--- a/car-media-common/res/values-gl/strings.xml
+++ b/car-media-common/res/values-gl/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Portada de álbum"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Sen título"</string>
 </resources>
diff --git a/car-media-common/res/values-gu/strings.xml b/car-media-common/res/values-gu/strings.xml
index 48ccea5..569394f 100644
--- a/car-media-common/res/values-gu/strings.xml
+++ b/car-media-common/res/values-gu/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"આલ્બમ આર્ટ"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"કોઈ શીર્ષક નથી"</string>
 </resources>
diff --git a/car-media-common/res/values-hi/strings.xml b/car-media-common/res/values-hi/strings.xml
index b4b9a92..f13088f 100644
--- a/car-media-common/res/values-hi/strings.xml
+++ b/car-media-common/res/values-hi/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"एल्‍बम आर्ट"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"कोई शीर्षक नहीं"</string>
 </resources>
diff --git a/car-media-common/res/values-hr/strings.xml b/car-media-common/res/values-hr/strings.xml
index 95065f6..00e19d1 100644
--- a/car-media-common/res/values-hr/strings.xml
+++ b/car-media-common/res/values-hr/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Slika naslovnice albuma"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Bez naslova"</string>
 </resources>
diff --git a/car-media-common/res/values-hu/strings.xml b/car-media-common/res/values-hu/strings.xml
index e346fe0..8631465 100644
--- a/car-media-common/res/values-hu/strings.xml
+++ b/car-media-common/res/values-hu/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Lemezborító"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Nincs cím"</string>
 </resources>
diff --git a/car-media-common/res/values-hy/strings.xml b/car-media-common/res/values-hy/strings.xml
index c60039e..197a067 100644
--- a/car-media-common/res/values-hy/strings.xml
+++ b/car-media-common/res/values-hy/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Ալբոմի շապիկ"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Անանուն"</string>
 </resources>
diff --git a/car-media-common/res/values-in/strings.xml b/car-media-common/res/values-in/strings.xml
index a7193d0..e331c0a 100644
--- a/car-media-common/res/values-in/strings.xml
+++ b/car-media-common/res/values-in/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Sampul Album"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Tanpa Judul"</string>
 </resources>
diff --git a/car-media-common/res/values-is/strings.xml b/car-media-common/res/values-is/strings.xml
index ea45f41..b26c4c6 100644
--- a/car-media-common/res/values-is/strings.xml
+++ b/car-media-common/res/values-is/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Plötuumslag"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Enginn titill"</string>
 </resources>
diff --git a/car-media-common/res/values-it/strings.xml b/car-media-common/res/values-it/strings.xml
index b965c9e..bab7f0a 100644
--- a/car-media-common/res/values-it/strings.xml
+++ b/car-media-common/res/values-it/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Copertina dell\'album"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Nessun titolo"</string>
 </resources>
diff --git a/car-media-common/res/values-iw/strings.xml b/car-media-common/res/values-iw/strings.xml
index be7d68f..9e12f85 100644
--- a/car-media-common/res/values-iw/strings.xml
+++ b/car-media-common/res/values-iw/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"עטיפת אלבום"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"ללא שם"</string>
 </resources>
diff --git a/car-media-common/res/values-ja/strings.xml b/car-media-common/res/values-ja/strings.xml
index 44ddb6d..8d46866 100644
--- a/car-media-common/res/values-ja/strings.xml
+++ b/car-media-common/res/values-ja/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"アルバムアート"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"タイトルなし"</string>
 </resources>
diff --git a/car-media-common/res/values-ka/strings.xml b/car-media-common/res/values-ka/strings.xml
index 3497af3..1e467fe 100644
--- a/car-media-common/res/values-ka/strings.xml
+++ b/car-media-common/res/values-ka/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"ალბომის გარეკანი"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"უსათაურო"</string>
 </resources>
diff --git a/car-media-common/res/values-kk/strings.xml b/car-media-common/res/values-kk/strings.xml
index 1062bd6..ec84f1a 100644
--- a/car-media-common/res/values-kk/strings.xml
+++ b/car-media-common/res/values-kk/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Альбом мұқабасы"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Атауы жоқ"</string>
 </resources>
diff --git a/car-media-common/res/values-km/strings.xml b/car-media-common/res/values-km/strings.xml
index 2fd01f2..a9320b1 100644
--- a/car-media-common/res/values-km/strings.xml
+++ b/car-media-common/res/values-km/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"​ក្រប​អាល់ប៊ុម"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"គ្មាន​ចំណងជើងទេ"</string>
 </resources>
diff --git a/car-media-common/res/values-kn/strings.xml b/car-media-common/res/values-kn/strings.xml
index 0ae31d6..4a02cfd 100644
--- a/car-media-common/res/values-kn/strings.xml
+++ b/car-media-common/res/values-kn/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"ಆಲ್ಬಮ್ ಕಲೆ"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"ಯಾವುದೇ ಶೀರ್ಷಿಕೆಯಿಲ್ಲ"</string>
 </resources>
diff --git a/car-media-common/res/values-ko/strings.xml b/car-media-common/res/values-ko/strings.xml
index 4e699e8..568f6de 100644
--- a/car-media-common/res/values-ko/strings.xml
+++ b/car-media-common/res/values-ko/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"앨범아트"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"제목 없음"</string>
 </resources>
diff --git a/car-media-common/res/values-ky/strings.xml b/car-media-common/res/values-ky/strings.xml
index 0ff7653..5dd1ccc 100644
--- a/car-media-common/res/values-ky/strings.xml
+++ b/car-media-common/res/values-ky/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Альбом мукабасы"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Аталышы жок"</string>
 </resources>
diff --git a/car-media-common/res/values-lo/strings.xml b/car-media-common/res/values-lo/strings.xml
index 98d9158..aee4892 100644
--- a/car-media-common/res/values-lo/strings.xml
+++ b/car-media-common/res/values-lo/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"ໜ້າປົກອະລະບ້ຳ"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"ບໍ່ມີຊື່"</string>
 </resources>
diff --git a/car-media-common/res/values-lt/strings.xml b/car-media-common/res/values-lt/strings.xml
index f79fe2e..b4f1926 100644
--- a/car-media-common/res/values-lt/strings.xml
+++ b/car-media-common/res/values-lt/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Albumo viršelis"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Nėra pavadinimo"</string>
 </resources>
diff --git a/car-media-common/res/values-lv/strings.xml b/car-media-common/res/values-lv/strings.xml
index 7250c12..d4b6044 100644
--- a/car-media-common/res/values-lv/strings.xml
+++ b/car-media-common/res/values-lv/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Albuma noformējums"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Bez nosaukuma"</string>
 </resources>
diff --git a/car-media-common/res/values-mk/strings.xml b/car-media-common/res/values-mk/strings.xml
index d3bd5ec..d46c551 100644
--- a/car-media-common/res/values-mk/strings.xml
+++ b/car-media-common/res/values-mk/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Корица на албум"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Без наслов"</string>
 </resources>
diff --git a/car-media-common/res/values-ml/strings.xml b/car-media-common/res/values-ml/strings.xml
index 69c6099..cd1743b 100644
--- a/car-media-common/res/values-ml/strings.xml
+++ b/car-media-common/res/values-ml/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"ആൽബം ആർട്ട്"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"പേരില്ല"</string>
 </resources>
diff --git a/car-media-common/res/values-mn/strings.xml b/car-media-common/res/values-mn/strings.xml
index 9cb3ef0..0cbec6a 100644
--- a/car-media-common/res/values-mn/strings.xml
+++ b/car-media-common/res/values-mn/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Цомгийн зураг"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Гарчиг алга"</string>
 </resources>
diff --git a/car-media-common/res/values-mr/strings.xml b/car-media-common/res/values-mr/strings.xml
index 6eb3270..450fddd 100644
--- a/car-media-common/res/values-mr/strings.xml
+++ b/car-media-common/res/values-mr/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"अल्बम कला"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"शीर्षक नाही"</string>
 </resources>
diff --git a/car-media-common/res/values-ms/strings.xml b/car-media-common/res/values-ms/strings.xml
index 9fb0d07..f5660bf 100644
--- a/car-media-common/res/values-ms/strings.xml
+++ b/car-media-common/res/values-ms/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Seni Album"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Tiada Tajuk"</string>
 </resources>
diff --git a/car-media-common/res/values-my/strings.xml b/car-media-common/res/values-my/strings.xml
index 88e294e..e717f45 100644
--- a/car-media-common/res/values-my/strings.xml
+++ b/car-media-common/res/values-my/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"အယ်လ်ဘမ်ပုံ"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"ခေါင်းစဉ် မရှိပါ"</string>
 </resources>
diff --git a/car-media-common/res/values-nb/strings.xml b/car-media-common/res/values-nb/strings.xml
index f3f6b18..b01654e 100644
--- a/car-media-common/res/values-nb/strings.xml
+++ b/car-media-common/res/values-nb/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Albumgrafikk"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Ingen tittel"</string>
 </resources>
diff --git a/car-media-common/res/values-ne/strings.xml b/car-media-common/res/values-ne/strings.xml
index 3e70c34..8e2bf79 100644
--- a/car-media-common/res/values-ne/strings.xml
+++ b/car-media-common/res/values-ne/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"एल्बम आर्ट"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"शीर्षक छैन"</string>
 </resources>
diff --git a/car-media-common/res/values-nl/strings.xml b/car-media-common/res/values-nl/strings.xml
index d22668f..8259676 100644
--- a/car-media-common/res/values-nl/strings.xml
+++ b/car-media-common/res/values-nl/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Albumhoes"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Geen titel"</string>
 </resources>
diff --git a/car-media-common/res/values-or/strings.xml b/car-media-common/res/values-or/strings.xml
new file mode 100644
index 0000000..a714293
--- /dev/null
+++ b/car-media-common/res/values-or/strings.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  Copyright 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.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="album_art" msgid="3392647029019061691">"ଆଲବମ୍ ଆର୍ଟ"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"କୌଣସି ଟାଇଟେଲ୍ ନାହିଁ"</string>
+</resources>
diff --git a/car-media-common/res/values-pa/strings.xml b/car-media-common/res/values-pa/strings.xml
index d35b304..e3a607b 100644
--- a/car-media-common/res/values-pa/strings.xml
+++ b/car-media-common/res/values-pa/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"ਐਲਬਮ ਕਲਾ"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"ਕੋਈ ਸਿਰਲੇਖ ਨਹੀਂ"</string>
 </resources>
diff --git a/car-media-common/res/values-pl/strings.xml b/car-media-common/res/values-pl/strings.xml
index b38f926..fd00ae5 100644
--- a/car-media-common/res/values-pl/strings.xml
+++ b/car-media-common/res/values-pl/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Okładka albumu"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Bez tytułu"</string>
 </resources>
diff --git a/car-media-common/res/values-pt-rPT/strings.xml b/car-media-common/res/values-pt-rPT/strings.xml
index 1ed6bf3..2ae65bf 100644
--- a/car-media-common/res/values-pt-rPT/strings.xml
+++ b/car-media-common/res/values-pt-rPT/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Imagem do álbum"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Sem título"</string>
 </resources>
diff --git a/car-media-common/res/values-pt/strings.xml b/car-media-common/res/values-pt/strings.xml
index d0ff223..1b39a7b 100644
--- a/car-media-common/res/values-pt/strings.xml
+++ b/car-media-common/res/values-pt/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Arte do álbum"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Sem título"</string>
 </resources>
diff --git a/car-media-common/res/values-ro/strings.xml b/car-media-common/res/values-ro/strings.xml
index b667514..38c53cc 100644
--- a/car-media-common/res/values-ro/strings.xml
+++ b/car-media-common/res/values-ro/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Grafica albumului"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Fără titlu"</string>
 </resources>
diff --git a/car-media-common/res/values-ru/strings.xml b/car-media-common/res/values-ru/strings.xml
index 30d8ce1..990650f 100644
--- a/car-media-common/res/values-ru/strings.xml
+++ b/car-media-common/res/values-ru/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Обложка альбома"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Без названия"</string>
 </resources>
diff --git a/car-media-common/res/values-si/strings.xml b/car-media-common/res/values-si/strings.xml
index 4ecd5c7..7da552b 100644
--- a/car-media-common/res/values-si/strings.xml
+++ b/car-media-common/res/values-si/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"ඇල්බම කලාව"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"මාතෘකාවක් නැත"</string>
 </resources>
diff --git a/car-media-common/res/values-sk/strings.xml b/car-media-common/res/values-sk/strings.xml
index 7c84b8c..d94bac4 100644
--- a/car-media-common/res/values-sk/strings.xml
+++ b/car-media-common/res/values-sk/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Obrázok albumu"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Bez názvu"</string>
 </resources>
diff --git a/car-media-common/res/values-sl/strings.xml b/car-media-common/res/values-sl/strings.xml
index e5a2fdd..683507c 100644
--- a/car-media-common/res/values-sl/strings.xml
+++ b/car-media-common/res/values-sl/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Slika albuma"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Brez naslova"</string>
 </resources>
diff --git a/car-media-common/res/values-sq/strings.xml b/car-media-common/res/values-sq/strings.xml
index c27e915..354b5ed 100644
--- a/car-media-common/res/values-sq/strings.xml
+++ b/car-media-common/res/values-sq/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Kopertina e albumit"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Pa titull"</string>
 </resources>
diff --git a/car-media-common/res/values-sr/strings.xml b/car-media-common/res/values-sr/strings.xml
index b638368..e6173ba 100644
--- a/car-media-common/res/values-sr/strings.xml
+++ b/car-media-common/res/values-sr/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Омот албума"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Без наслова"</string>
 </resources>
diff --git a/car-media-common/res/values-sv/strings.xml b/car-media-common/res/values-sv/strings.xml
index 111c939..ce52ecf 100644
--- a/car-media-common/res/values-sv/strings.xml
+++ b/car-media-common/res/values-sv/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Skivomslag"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Ingen titel"</string>
 </resources>
diff --git a/car-media-common/res/values-sw/strings.xml b/car-media-common/res/values-sw/strings.xml
index 6a8da9d..282555c 100644
--- a/car-media-common/res/values-sw/strings.xml
+++ b/car-media-common/res/values-sw/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Sanaa ya Albamu"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Hakuna Jina"</string>
 </resources>
diff --git a/car-media-common/res/values-ta/strings.xml b/car-media-common/res/values-ta/strings.xml
index ded4c56..dd522b8 100644
--- a/car-media-common/res/values-ta/strings.xml
+++ b/car-media-common/res/values-ta/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"ஆல்பம் ஆர்ட்"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"தலைப்பு இல்லை"</string>
 </resources>
diff --git a/car-media-common/res/values-te/strings.xml b/car-media-common/res/values-te/strings.xml
index eb11da8..62a7464 100644
--- a/car-media-common/res/values-te/strings.xml
+++ b/car-media-common/res/values-te/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"ఆల్బమ్ ఆర్ట్"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"శీర్షిక లేదు"</string>
 </resources>
diff --git a/car-media-common/res/values-th/strings.xml b/car-media-common/res/values-th/strings.xml
index 34d0ca2..f642719 100644
--- a/car-media-common/res/values-th/strings.xml
+++ b/car-media-common/res/values-th/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"ปกอัลบั้ม"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"ไม่มีชื่อ"</string>
 </resources>
diff --git a/car-media-common/res/values-tl/strings.xml b/car-media-common/res/values-tl/strings.xml
index c2f2ef5..a2da896 100644
--- a/car-media-common/res/values-tl/strings.xml
+++ b/car-media-common/res/values-tl/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Album Art"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Walang Pamagat"</string>
 </resources>
diff --git a/car-media-common/res/values-tr/strings.xml b/car-media-common/res/values-tr/strings.xml
index 98b90d6..6f717ac 100644
--- a/car-media-common/res/values-tr/strings.xml
+++ b/car-media-common/res/values-tr/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Albüm Kapağı"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Başlıksız"</string>
 </resources>
diff --git a/car-media-common/res/values-uk/strings.xml b/car-media-common/res/values-uk/strings.xml
index 84e09e1..0661490 100644
--- a/car-media-common/res/values-uk/strings.xml
+++ b/car-media-common/res/values-uk/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Обкладинка альбому"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Без назви"</string>
 </resources>
diff --git a/car-media-common/res/values-ur/strings.xml b/car-media-common/res/values-ur/strings.xml
index e746f3a..ccf505c 100644
--- a/car-media-common/res/values-ur/strings.xml
+++ b/car-media-common/res/values-ur/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"البم آرٹ"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"کوئی عنوان نہیں ہے"</string>
 </resources>
diff --git a/car-media-common/res/values-uz/strings.xml b/car-media-common/res/values-uz/strings.xml
index 5c97fc1..f3e8826 100644
--- a/car-media-common/res/values-uz/strings.xml
+++ b/car-media-common/res/values-uz/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Albom muqovasi"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Nomsiz"</string>
 </resources>
diff --git a/car-media-common/res/values-vi/strings.xml b/car-media-common/res/values-vi/strings.xml
index ba84106..2a99840 100644
--- a/car-media-common/res/values-vi/strings.xml
+++ b/car-media-common/res/values-vi/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Ảnh bìa album"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Không có tiêu đề"</string>
 </resources>
diff --git a/car-media-common/res/values-zh-rCN/strings.xml b/car-media-common/res/values-zh-rCN/strings.xml
index 3370ca3..b3ddef1 100644
--- a/car-media-common/res/values-zh-rCN/strings.xml
+++ b/car-media-common/res/values-zh-rCN/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"专辑封面"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"无标题"</string>
 </resources>
diff --git a/car-media-common/res/values-zh-rHK/strings.xml b/car-media-common/res/values-zh-rHK/strings.xml
index 9376f80..6ce371a 100644
--- a/car-media-common/res/values-zh-rHK/strings.xml
+++ b/car-media-common/res/values-zh-rHK/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"專輯封面"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"無標題"</string>
 </resources>
diff --git a/car-media-common/res/values-zh-rTW/strings.xml b/car-media-common/res/values-zh-rTW/strings.xml
index 9376f80..6ce371a 100644
--- a/car-media-common/res/values-zh-rTW/strings.xml
+++ b/car-media-common/res/values-zh-rTW/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"專輯封面"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"無標題"</string>
 </resources>
diff --git a/car-media-common/res/values-zu/strings.xml b/car-media-common/res/values-zu/strings.xml
index f2c1a2e..cde3b48 100644
--- a/car-media-common/res/values-zu/strings.xml
+++ b/car-media-common/res/values-zu/strings.xml
@@ -18,4 +18,5 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="album_art" msgid="3392647029019061691">"Ubuciko be-albhamu"</string>
+    <string name="metadata_default_title" msgid="5902775732281325081">"Asikho isihloko"</string>
 </resources>
diff --git a/car-settings-lib/Android.mk b/car-settings-lib/Android.mk
index be71fda..9cddc18 100644
--- a/car-settings-lib/Android.mk
+++ b/car-settings-lib/Android.mk
@@ -33,6 +33,8 @@
 
 LOCAL_PROGUARD_ENABLED := disabled
 
+LOCAL_MIN_SDK_VERSION := 24
+
 include $(BUILD_STATIC_JAVA_LIBRARY)
 
 # Use the following include to make our test apk.
diff --git a/car-settings-lib/res/values-af/strings.xml b/car-settings-lib/res/values-af/strings.xml
index 96e6123..38a0e1b 100644
--- a/car-settings-lib/res/values-af/strings.xml
+++ b/car-settings-lib/res/values-af/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Voorgestel"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Alle tale"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Veld kan nie leeg wees nie."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Ingevoerde gebruikernaam is ongeldig."</string>
 </resources>
diff --git a/car-settings-lib/res/values-am/strings.xml b/car-settings-lib/res/values-am/strings.xml
index 18e7bac..7aec3e0 100644
--- a/car-settings-lib/res/values-am/strings.xml
+++ b/car-settings-lib/res/values-am/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"የተጠቆሙ"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"ሁሉም ቋንቋዎች"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"መስክ ባዶ መሆን አይችልም።"</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"የገባው ተጠቃሚ ስም የማይሠራ ነው።"</string>
 </resources>
diff --git a/car-settings-lib/res/values-ar/strings.xml b/car-settings-lib/res/values-ar/strings.xml
index 250b731..2fb7894 100644
--- a/car-settings-lib/res/values-ar/strings.xml
+++ b/car-settings-lib/res/values-ar/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"اللغات المقترحة"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"جميع اللغات"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"يجب عدم ترك الحقل فارغًا."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"اسم المستخدم المُدخل غير صالح."</string>
 </resources>
diff --git a/car-settings-lib/res/values-as/strings.xml b/car-settings-lib/res/values-as/strings.xml
index 834fff1..747e8ab 100644
--- a/car-settings-lib/res/values-as/strings.xml
+++ b/car-settings-lib/res/values-as/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"পৰামৰ্শ দিয়া ভাষা"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"সকলো ভাষা"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"এই খালী ঠাই পূৰ নকৰাকৈ এৰিব নোৱাৰি।"</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"আপুনি দিয়া ব্য়ৱহাৰকাৰীৰ নাম মান্য় নহয়।"</string>
 </resources>
diff --git a/car-settings-lib/res/values-az/strings.xml b/car-settings-lib/res/values-az/strings.xml
index 218b74e..29f7cfb 100644
--- a/car-settings-lib/res/values-az/strings.xml
+++ b/car-settings-lib/res/values-az/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Təklif edilmiş"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Bütün dillər"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Sahə boş ola bilməz."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Daxil edilən istifadəçi adı yanlışdır."</string>
 </resources>
diff --git a/car-settings-lib/res/values-b+sr+Latn/strings.xml b/car-settings-lib/res/values-b+sr+Latn/strings.xml
index 5012ba8..c9450b1 100644
--- a/car-settings-lib/res/values-b+sr+Latn/strings.xml
+++ b/car-settings-lib/res/values-b+sr+Latn/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Predloženi"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Svi jezici"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Polje ne sme da bude prazno."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Korisničko ime koje ste uneli je nevažeće."</string>
 </resources>
diff --git a/car-settings-lib/res/values-be/strings.xml b/car-settings-lib/res/values-be/strings.xml
index 349c7ba..0a55864 100644
--- a/car-settings-lib/res/values-be/strings.xml
+++ b/car-settings-lib/res/values-be/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Прапанавана"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Усе мовы"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Поле не можа быць пустым."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Уведзена несапраўднае імя карыстальніка"</string>
 </resources>
diff --git a/car-settings-lib/res/values-bg/strings.xml b/car-settings-lib/res/values-bg/strings.xml
index a6c63e7..7427987 100644
--- a/car-settings-lib/res/values-bg/strings.xml
+++ b/car-settings-lib/res/values-bg/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Предложени"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Всички езици"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Полето трябва да се попълни."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Въведеното потребителско име е невалидно."</string>
 </resources>
diff --git a/car-settings-lib/res/values-bn/strings.xml b/car-settings-lib/res/values-bn/strings.xml
index 2c4ce46..2023f4f 100644
--- a/car-settings-lib/res/values-bn/strings.xml
+++ b/car-settings-lib/res/values-bn/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"প্রস্তাবিত"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"সমস্ত ভাষা"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"ক্ষেত্র খালি রাখা যাবে না।"</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"প্রদান করা ব্যবহারকারীর নামটি সঠিক নয়।"</string>
 </resources>
diff --git a/car-settings-lib/res/values-bs/strings.xml b/car-settings-lib/res/values-bs/strings.xml
index 951720c..adf86c9 100644
--- a/car-settings-lib/res/values-bs/strings.xml
+++ b/car-settings-lib/res/values-bs/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Predloženo"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Svi jezici"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Polje ne može biti prazno."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Korisničko ime koje ste unijeli je nevažeće."</string>
 </resources>
diff --git a/car-settings-lib/res/values-ca/strings.xml b/car-settings-lib/res/values-ca/strings.xml
index be8eb01..ee2b958 100644
--- a/car-settings-lib/res/values-ca/strings.xml
+++ b/car-settings-lib/res/values-ca/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Suggerits"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Tots els idiomes"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"El camp no pot estar en blanc."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"El nom d\'usuari que has introduït no és vàlid."</string>
 </resources>
diff --git a/car-settings-lib/res/values-cs/strings.xml b/car-settings-lib/res/values-cs/strings.xml
index 0483e2f..fca045b 100644
--- a/car-settings-lib/res/values-cs/strings.xml
+++ b/car-settings-lib/res/values-cs/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Navrženo"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Všechny jazyky"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Pole nesmí být prázdné."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Zadané uživatelské jméno není platné."</string>
 </resources>
diff --git a/car-settings-lib/res/values-da/strings.xml b/car-settings-lib/res/values-da/strings.xml
index dd14ebd..2a585cb 100644
--- a/car-settings-lib/res/values-da/strings.xml
+++ b/car-settings-lib/res/values-da/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Foreslået"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Alle sprog"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Feltet må ikke være tomt."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Det brugernavn, du har angivet, er ugyldigt."</string>
 </resources>
diff --git a/car-settings-lib/res/values-de/strings.xml b/car-settings-lib/res/values-de/strings.xml
index 71aad62..a138ce7 100644
--- a/car-settings-lib/res/values-de/strings.xml
+++ b/car-settings-lib/res/values-de/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Vorgeschlagen"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Alle Sprachen"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Das Feld darf nicht leer sein."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Der eingegebene Nutzername ist ungültig."</string>
 </resources>
diff --git a/car-settings-lib/res/values-el/strings.xml b/car-settings-lib/res/values-el/strings.xml
index 3faed87..2496924 100644
--- a/car-settings-lib/res/values-el/strings.xml
+++ b/car-settings-lib/res/values-el/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Προτεινόμενες"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Όλες οι γλώσσες"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Το πεδίο δεν μπορεί να παραμείνει κενό."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Το όνομα χρήστη που καταχωρίστηκε είναι μη έγκυρο."</string>
 </resources>
diff --git a/car-settings-lib/res/values-en-rAU/strings.xml b/car-settings-lib/res/values-en-rAU/strings.xml
index f95fdbc..96a64e0 100644
--- a/car-settings-lib/res/values-en-rAU/strings.xml
+++ b/car-settings-lib/res/values-en-rAU/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Suggested"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"All languages"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Field can\'t be blank."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Username entered is invalid."</string>
 </resources>
diff --git a/car-settings-lib/res/values-en-rCA/strings.xml b/car-settings-lib/res/values-en-rCA/strings.xml
index f95fdbc..96a64e0 100644
--- a/car-settings-lib/res/values-en-rCA/strings.xml
+++ b/car-settings-lib/res/values-en-rCA/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Suggested"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"All languages"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Field can\'t be blank."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Username entered is invalid."</string>
 </resources>
diff --git a/car-settings-lib/res/values-en-rGB/strings.xml b/car-settings-lib/res/values-en-rGB/strings.xml
index f95fdbc..96a64e0 100644
--- a/car-settings-lib/res/values-en-rGB/strings.xml
+++ b/car-settings-lib/res/values-en-rGB/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Suggested"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"All languages"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Field can\'t be blank."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Username entered is invalid."</string>
 </resources>
diff --git a/car-settings-lib/res/values-en-rIN/strings.xml b/car-settings-lib/res/values-en-rIN/strings.xml
index f95fdbc..96a64e0 100644
--- a/car-settings-lib/res/values-en-rIN/strings.xml
+++ b/car-settings-lib/res/values-en-rIN/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Suggested"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"All languages"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Field can\'t be blank."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Username entered is invalid."</string>
 </resources>
diff --git a/car-settings-lib/res/values-en-rXC/strings.xml b/car-settings-lib/res/values-en-rXC/strings.xml
index 9366a50..80192d2 100644
--- a/car-settings-lib/res/values-en-rXC/strings.xml
+++ b/car-settings-lib/res/values-en-rXC/strings.xml
@@ -17,6 +17,8 @@
 
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‏‏‏‏‏‏‎‏‏‏‏‏‏‎‎‏‎‏‏‎‏‎‏‏‎‏‏‎‏‎‎‎‎‎‎‎‏‎‎‎‏‏‏‎‎‎‏‎‎‏‏‏‏‏‏‏‎‏‎‎‎‎‎‏‏‎Suggested‎‏‎‎‏‎"</string>
-    <string name="language_picker_list_all_header" msgid="3907663373765943630">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‏‎‏‏‎‏‏‎‎‎‏‏‏‎‏‎‏‏‎‎‏‏‏‏‎‎‏‎‎‎‏‎‎‏‏‏‏‏‏‏‎‎‎‏‏‏‏‏‏‎‏‎‎‎‎‏‎‏‎‎‏‏‏‎‎All languages‎‏‎‎‏‎"</string>
+    <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‏‏‏‏‏‏‎‏‏‏‏‏‏‎‎‏‎‏‏‎‏‎‏‏‎‏‏‎‏‎‎‎‎‎‎‎‏‎‎‎‏‏‏‎‎‎‏‎‎‏‏‏‏‏‏‏‎‏‎‎‎‎‎‏‏‎Suggested‎‏‎‎‏‎"</string>
+    <string name="language_picker_list_all_header" msgid="3907663373765943630">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‏‎‏‏‎‏‏‎‎‎‏‏‏‎‏‎‏‏‎‎‏‏‏‏‎‎‏‎‎‎‏‎‎‏‏‏‏‏‏‏‎‎‎‏‏‏‏‏‏‎‏‎‎‎‎‏‎‏‎‎‏‏‏‎‎All languages‎‏‎‎‏‎"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‏‏‏‎‎‏‎‏‏‏‏‎‎‏‎‎‎‎‎‎‎‏‏‏‏‏‎‎‎‏‏‎‎‏‎‎‏‏‏‏‏‎‏‏‎‏‏‏‎‎‏‏‎‏‎‎‎‎‎‏‏‎‏‎‏‎Field can’t be blank.‎‏‎‎‏‎"</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‏‏‏‏‏‏‎‎‏‎‎‏‏‏‎‎‏‎‎‏‏‏‏‏‎‎‏‏‎‏‏‏‎‏‎‏‎‎‏‎‏‎‎‏‎‎‏‎‏‎‎‎‏‎‏‎‎‎‎‎‎‏‎‏‎‎Username entered is invalid.‎‏‎‎‏‎"</string>
 </resources>
diff --git a/car-settings-lib/res/values-es-rUS/strings.xml b/car-settings-lib/res/values-es-rUS/strings.xml
index 7b454c8..92eff9f 100644
--- a/car-settings-lib/res/values-es-rUS/strings.xml
+++ b/car-settings-lib/res/values-es-rUS/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Sugerencias"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Todos los idiomas"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Este campo no puede quedar vacío."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"El nombre de usuario ingresado no es válido."</string>
 </resources>
diff --git a/car-settings-lib/res/values-es/strings.xml b/car-settings-lib/res/values-es/strings.xml
index 7b454c8..0e70ac6 100644
--- a/car-settings-lib/res/values-es/strings.xml
+++ b/car-settings-lib/res/values-es/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Sugerencias"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Todos los idiomas"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"El campo no puede estar vacío."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"El nombre de usuario introducido no es válido."</string>
 </resources>
diff --git a/car-settings-lib/res/values-et/strings.xml b/car-settings-lib/res/values-et/strings.xml
index 3955f24..0282368 100644
--- a/car-settings-lib/res/values-et/strings.xml
+++ b/car-settings-lib/res/values-et/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Soovitatud"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Kõik keeled"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Väli ei tohi olla tühi."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Sisestatud kasutajanimi on sobimatu."</string>
 </resources>
diff --git a/car-settings-lib/res/values-eu/strings.xml b/car-settings-lib/res/values-eu/strings.xml
index c67ea55..c8c0e10 100644
--- a/car-settings-lib/res/values-eu/strings.xml
+++ b/car-settings-lib/res/values-eu/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Iradokitakoak"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Hizkuntza guztiak"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Eremuak ezin du hutsik egon."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Idatzitako erabiltzaile-izenak ez du balio."</string>
 </resources>
diff --git a/car-settings-lib/res/values-fa/strings.xml b/car-settings-lib/res/values-fa/strings.xml
index 60b2806..3ce1002 100644
--- a/car-settings-lib/res/values-fa/strings.xml
+++ b/car-settings-lib/res/values-fa/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"پیشنهادشده"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"همه زبان‌ها"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"این فیلد نمی‌تواند خالی باشد."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"نام کاربری واردشده نامعتبر است."</string>
 </resources>
diff --git a/car-settings-lib/res/values-fi/strings.xml b/car-settings-lib/res/values-fi/strings.xml
index cd453ef..cb5f2c9 100644
--- a/car-settings-lib/res/values-fi/strings.xml
+++ b/car-settings-lib/res/values-fi/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Ehdotettu"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Kaikki kielet"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Kenttä ei voi olla tyhjä."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Annettu käyttäjänimi on virheellinen."</string>
 </resources>
diff --git a/car-settings-lib/res/values-fr-rCA/strings.xml b/car-settings-lib/res/values-fr-rCA/strings.xml
index 639b6bb..ee93f50 100644
--- a/car-settings-lib/res/values-fr-rCA/strings.xml
+++ b/car-settings-lib/res/values-fr-rCA/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Suggestions"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Toutes les langues"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Champ obligatoire."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Le nom d\'utilisateur entré n\'est pas valide."</string>
 </resources>
diff --git a/car-settings-lib/res/values-fr/strings.xml b/car-settings-lib/res/values-fr/strings.xml
index 4056763..250d38a 100644
--- a/car-settings-lib/res/values-fr/strings.xml
+++ b/car-settings-lib/res/values-fr/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Suggestion"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Toutes les langues"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Champ obligatoire."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Le nom d\'utilisateur saisi est incorrect."</string>
 </resources>
diff --git a/car-settings-lib/res/values-gl/strings.xml b/car-settings-lib/res/values-gl/strings.xml
index d274e9b..e2a772a 100644
--- a/car-settings-lib/res/values-gl/strings.xml
+++ b/car-settings-lib/res/values-gl/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Idiomas suxeridos"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Todos os idiomas"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"O campo non pode estar en branco."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"O nome de usuario que introduciches non é válido."</string>
 </resources>
diff --git a/car-settings-lib/res/values-gu/strings.xml b/car-settings-lib/res/values-gu/strings.xml
index 637eb1b..22826c7 100644
--- a/car-settings-lib/res/values-gu/strings.xml
+++ b/car-settings-lib/res/values-gu/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"સૂચવેલા"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"બધી ભાષાઓ"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"ફીલ્ડ ખાલી રાખી શકાય નહીં."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"દાખલ કરેલું વપરાશકર્તાનું નામ અમાન્ય છે."</string>
 </resources>
diff --git a/car-settings-lib/res/values-hi/strings.xml b/car-settings-lib/res/values-hi/strings.xml
index 2fe1e97..042be3b 100644
--- a/car-settings-lib/res/values-hi/strings.xml
+++ b/car-settings-lib/res/values-hi/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"सुझाए गए"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"सभी भाषाएं"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"नाम लिखने की जगह (फ़ील्ड) खाली नहीं रखी जा सकती."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"डाला गया उपयोगकर्ता नाम गलत है."</string>
 </resources>
diff --git a/car-settings-lib/res/values-hr/strings.xml b/car-settings-lib/res/values-hr/strings.xml
index 951720c..c0a69ff 100644
--- a/car-settings-lib/res/values-hr/strings.xml
+++ b/car-settings-lib/res/values-hr/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Predloženo"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Svi jezici"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Polje ne može biti prazno."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Uneseno korisničko ime nije važeće."</string>
 </resources>
diff --git a/car-settings-lib/res/values-hu/strings.xml b/car-settings-lib/res/values-hu/strings.xml
index a3b81ba..275ea75 100644
--- a/car-settings-lib/res/values-hu/strings.xml
+++ b/car-settings-lib/res/values-hu/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Javasolt"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Minden nyelv"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"A mező nem lehet üres."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"A megadott felhasználónév érvénytelen."</string>
 </resources>
diff --git a/car-settings-lib/res/values-hy/strings.xml b/car-settings-lib/res/values-hy/strings.xml
index 98eb767..fcab9c7 100644
--- a/car-settings-lib/res/values-hy/strings.xml
+++ b/car-settings-lib/res/values-hy/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Առաջարկվող"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Բոլոր լեզուները"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Դաշտը չի կարող դատարկ լինել:"</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Մուտքագրված օգտանունն անվավեր է։"</string>
 </resources>
diff --git a/car-settings-lib/res/values-in/strings.xml b/car-settings-lib/res/values-in/strings.xml
index 489b4d8..51e4d3e 100644
--- a/car-settings-lib/res/values-in/strings.xml
+++ b/car-settings-lib/res/values-in/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Disarankan"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Semua bahasa"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Kolom harus diisi."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Nama pengguna yang dimasukkan tidak valid."</string>
 </resources>
diff --git a/car-settings-lib/res/values-is/strings.xml b/car-settings-lib/res/values-is/strings.xml
index 48c3fb8..3dffde3 100644
--- a/car-settings-lib/res/values-is/strings.xml
+++ b/car-settings-lib/res/values-is/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Tillögur"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Öll tungumál"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Reiturinn má ekki vera auður."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Ógilt notandanafn var slegið inn."</string>
 </resources>
diff --git a/car-settings-lib/res/values-it/strings.xml b/car-settings-lib/res/values-it/strings.xml
index 594a236..69e1425 100644
--- a/car-settings-lib/res/values-it/strings.xml
+++ b/car-settings-lib/res/values-it/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Suggerite"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Tutte le lingue"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Il campo non può essere vuoto."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Il nome utente inserito non è valido."</string>
 </resources>
diff --git a/car-settings-lib/res/values-iw/strings.xml b/car-settings-lib/res/values-iw/strings.xml
index b581394..180b3e8 100644
--- a/car-settings-lib/res/values-iw/strings.xml
+++ b/car-settings-lib/res/values-iw/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"הצעות"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"כל השפות"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"חובה למלא את השדה."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"שם המשתמש שהוזן לא חוקי."</string>
 </resources>
diff --git a/car-settings-lib/res/values-ja/strings.xml b/car-settings-lib/res/values-ja/strings.xml
index d103fc3..6374217 100644
--- a/car-settings-lib/res/values-ja/strings.xml
+++ b/car-settings-lib/res/values-ja/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"言語の候補"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"すべての言語"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"フィールドは空欄にできません。"</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"入力されたユーザー名が無効です。"</string>
 </resources>
diff --git a/car-settings-lib/res/values-ka/strings.xml b/car-settings-lib/res/values-ka/strings.xml
index 2c4b24a..6f93ba9 100644
--- a/car-settings-lib/res/values-ka/strings.xml
+++ b/car-settings-lib/res/values-ka/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"რეკომენდებული"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"ყველა ენა"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"არ შეიძლება ველი ცარიელი იყოს."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"მომხმარებლის სახელი არასწორადაა შეყვანილი."</string>
 </resources>
diff --git a/car-settings-lib/res/values-kk/strings.xml b/car-settings-lib/res/values-kk/strings.xml
index 9d63cfa..ebf2013 100644
--- a/car-settings-lib/res/values-kk/strings.xml
+++ b/car-settings-lib/res/values-kk/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Ұсынылған"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Барлық тілдер"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Өріс бос болмауы керек."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Енгізілген пайдаланушы аты жарамсыз."</string>
 </resources>
diff --git a/car-settings-lib/res/values-km/strings.xml b/car-settings-lib/res/values-km/strings.xml
index 9645b41..2274c4c 100644
--- a/car-settings-lib/res/values-km/strings.xml
+++ b/car-settings-lib/res/values-km/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"បាន​ណែនាំ"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"ភាសាទាំងអស់"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"កន្លែងបញ្ចូលមិន​អាច​ទទេឡើយ។"</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"ឈ្មោះ​អ្នកប្រើប្រាស់​ដែល​បាន​បញ្ចូល​គឺមិនត្រឹមត្រូវទេ។"</string>
 </resources>
diff --git a/car-settings-lib/res/values-kn/strings.xml b/car-settings-lib/res/values-kn/strings.xml
index 285b510..c5815cc 100644
--- a/car-settings-lib/res/values-kn/strings.xml
+++ b/car-settings-lib/res/values-kn/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"ಸೂಚಿಸಲಾಗಿರುವುದು"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"ಎಲ್ಲಾ ಭಾಷೆಗಳು"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"ಕ್ಷೇತ್ರವು ಖಾಲಿ ಇರುವಂತಿಲ್ಲ."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"ನಮೂದಿಸಿದ ಬಳಕೆದಾರರ ಹೆಸರು ಅಮಾನ್ಯವಾಗಿದೆ."</string>
 </resources>
diff --git a/car-settings-lib/res/values-ko/strings.xml b/car-settings-lib/res/values-ko/strings.xml
index e666fa1..1a818d9 100644
--- a/car-settings-lib/res/values-ko/strings.xml
+++ b/car-settings-lib/res/values-ko/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"추천"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"모든 언어"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"입력란을 비워 둘 수 없습니다."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"입력한 사용자 이름이 올바르지 않습니다."</string>
 </resources>
diff --git a/car-settings-lib/res/values-ky/strings.xml b/car-settings-lib/res/values-ky/strings.xml
index 417838c..03e5756 100644
--- a/car-settings-lib/res/values-ky/strings.xml
+++ b/car-settings-lib/res/values-ky/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Сунушталган тилдер"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Бардык тилдер"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Талаа бош болбошу керек."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Киргизилген колдонуучунун аты жараксыз."</string>
 </resources>
diff --git a/car-settings-lib/res/values-lo/strings.xml b/car-settings-lib/res/values-lo/strings.xml
index e2c5e74..439bafa 100644
--- a/car-settings-lib/res/values-lo/strings.xml
+++ b/car-settings-lib/res/values-lo/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"ແນະນຳ"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"ທຸກພາສາ"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"ຊ່ອງຂໍ້ມູນບໍ່ສາມາດຫວ່າງເປົ່າໄດ້."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"ຊື່ຜູ້ໃຊ້ທີ່ປ້ອນເຂົ້າບໍ່ຖືກຕ້ອງ."</string>
 </resources>
diff --git a/car-settings-lib/res/values-lt/strings.xml b/car-settings-lib/res/values-lt/strings.xml
index 75a21f3..3b3f481 100644
--- a/car-settings-lib/res/values-lt/strings.xml
+++ b/car-settings-lib/res/values-lt/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Siūloma"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Visos kalbos"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Laukas negali būti tuščias."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Įvestas naudotojo vardas yra netinkamas."</string>
 </resources>
diff --git a/car-settings-lib/res/values-lv/strings.xml b/car-settings-lib/res/values-lv/strings.xml
index 7c36030..856dcf4 100644
--- a/car-settings-lib/res/values-lv/strings.xml
+++ b/car-settings-lib/res/values-lv/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Ieteiktās"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Visas valodas"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Lauks nedrīkst būt tukšs."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Ievadītais lietotājvārds nav derīgs."</string>
 </resources>
diff --git a/car-settings-lib/res/values-mk/strings.xml b/car-settings-lib/res/values-mk/strings.xml
index ae38e48..f344b18 100644
--- a/car-settings-lib/res/values-mk/strings.xml
+++ b/car-settings-lib/res/values-mk/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Предложени"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Сите јазици"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Полето не може да биде празно."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Внесеното корисничко име е неважечко."</string>
 </resources>
diff --git a/car-settings-lib/res/values-ml/strings.xml b/car-settings-lib/res/values-ml/strings.xml
index 427f6fc..afb887d 100644
--- a/car-settings-lib/res/values-ml/strings.xml
+++ b/car-settings-lib/res/values-ml/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"നിര്‍‌ദ്ദേശിക്കുന്നവ"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"എല്ലാ ഭാഷകളും"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"ഫീൽഡ് ശൂന്യമായിടരുത്."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"നൽകിയ ഉപയോക്തൃ നാമം അസാധുവാണ്."</string>
 </resources>
diff --git a/car-settings-lib/res/values-mn/strings.xml b/car-settings-lib/res/values-mn/strings.xml
index 7922a8a..d747c7b 100644
--- a/car-settings-lib/res/values-mn/strings.xml
+++ b/car-settings-lib/res/values-mn/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Санал болгосон"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Бүх хэл"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Талбар хоосон байж болохгүй."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Оруулсан хэрэглэгчийн нэр буруу байна."</string>
 </resources>
diff --git a/car-settings-lib/res/values-mr/strings.xml b/car-settings-lib/res/values-mr/strings.xml
index 8a296b4..f915f65 100644
--- a/car-settings-lib/res/values-mr/strings.xml
+++ b/car-settings-lib/res/values-mr/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"सूचित"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"सर्व भाषा"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"फील्ड रिकामे असू शकत नाही."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"एंटर केलेले वापरकर्ता नाव चुकीचे आहे."</string>
 </resources>
diff --git a/car-settings-lib/res/values-ms/strings.xml b/car-settings-lib/res/values-ms/strings.xml
index f68ade6..e67f995 100644
--- a/car-settings-lib/res/values-ms/strings.xml
+++ b/car-settings-lib/res/values-ms/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Dicadangkan"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Semua bahasa"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Medan tidak boleh kosong."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Nama pengguna yang dimasukkan tidak sah."</string>
 </resources>
diff --git a/car-settings-lib/res/values-my/strings.xml b/car-settings-lib/res/values-my/strings.xml
index 25753cd..dd448fa 100644
--- a/car-settings-lib/res/values-my/strings.xml
+++ b/car-settings-lib/res/values-my/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"အကြံပြုထားသော"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"ဘာသာစကားအားလုံး"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"အကွက်ကို ကွက်လပ်ထား၍ မရပါ။"</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"ထည့်ထားသော အသုံးပြုသူအမည် မမှန်ကန်ပါ။"</string>
 </resources>
diff --git a/car-settings-lib/res/values-nb/strings.xml b/car-settings-lib/res/values-nb/strings.xml
index 2aae538..77dc43a 100644
--- a/car-settings-lib/res/values-nb/strings.xml
+++ b/car-settings-lib/res/values-nb/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Foreslått"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Alle språk"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Feltet må fylles ut."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Brukernavnet du skrev inn, er ugyldig."</string>
 </resources>
diff --git a/car-settings-lib/res/values-ne/strings.xml b/car-settings-lib/res/values-ne/strings.xml
index 9087871..6d32ddc 100644
--- a/car-settings-lib/res/values-ne/strings.xml
+++ b/car-settings-lib/res/values-ne/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"सुझाव दिइयो"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"सम्पूर्ण भाषाहरू"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"फिल्ड खाली हुन सक्दैन।"</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"प्रविष्ट गरिएको प्रयोगकर्ता नाम अमान्य छ।"</string>
 </resources>
diff --git a/car-settings-lib/res/values-nl/strings.xml b/car-settings-lib/res/values-nl/strings.xml
index 08fefd5..25f84ef 100644
--- a/car-settings-lib/res/values-nl/strings.xml
+++ b/car-settings-lib/res/values-nl/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Voorgesteld"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Alle talen"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Veld mag niet leeg zijn."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"De ingevoerde gebruikersnaam is ongeldig."</string>
 </resources>
diff --git a/car-settings-lib/res/values-or/strings.xml b/car-settings-lib/res/values-or/strings.xml
new file mode 100644
index 0000000..3690ef6
--- /dev/null
+++ b/car-settings-lib/res/values-or/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+    Copyright (C) 2018 Google Inc.
+
+    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="language_picker_list_suggested_header" msgid="8931437200168779395">"ପରାମର୍ଶିତ"</string>
+    <string name="language_picker_list_all_header" msgid="3907663373765943630">"ସମସ୍ତ ଭାଷା"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"ସ୍ଥାନକୁ ଖାଲି ଛାଡ଼ି ହେବନାହିଁ।"</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"ଲେଖାଯାଇଥିବା ଉପଯୋଗକର୍ତ୍ତାନାମଟି ଠିକ୍‍ ନାହିଁ।"</string>
+</resources>
diff --git a/car-settings-lib/res/values-pa/strings.xml b/car-settings-lib/res/values-pa/strings.xml
index 3f3c448..c501aaf 100644
--- a/car-settings-lib/res/values-pa/strings.xml
+++ b/car-settings-lib/res/values-pa/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"ਸੁਝਾਏ ਗਏ"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"ਸਾਰੀਆਂ ਭਾਸ਼ਾਵਾਂ"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"ਖੇਤਰ ਖਾਲੀ ਨਹੀਂ ਛੱਡਿਆ ਜਾ ਸਕਦਾ।"</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"ਦਾਖਲ ਕੀਤਾ ਗਿਆ ਵਰਤੋਂਕਾਰ ਨਾਮ ਅਵੈਧ ਹੈ।"</string>
 </resources>
diff --git a/car-settings-lib/res/values-pl/strings.xml b/car-settings-lib/res/values-pl/strings.xml
index 6460d2f..00bbad3 100644
--- a/car-settings-lib/res/values-pl/strings.xml
+++ b/car-settings-lib/res/values-pl/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Sugerowane"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Wszystkie języki"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Pole nie może być puste."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Podana nazwa użytkownika jest nieprawidłowa."</string>
 </resources>
diff --git a/car-settings-lib/res/values-pt-rPT/strings.xml b/car-settings-lib/res/values-pt-rPT/strings.xml
index 614fc52..7ad6367 100644
--- a/car-settings-lib/res/values-pt-rPT/strings.xml
+++ b/car-settings-lib/res/values-pt-rPT/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Sugeridos"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Todos os idiomas"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"O campo não pode estar em branco."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"O nome de utilizador introduzido é inválido."</string>
 </resources>
diff --git a/car-settings-lib/res/values-pt/strings.xml b/car-settings-lib/res/values-pt/strings.xml
index 614fc52..ac5fb11 100644
--- a/car-settings-lib/res/values-pt/strings.xml
+++ b/car-settings-lib/res/values-pt/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Sugeridos"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Todos os idiomas"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"O campo não pode ficar em branco."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"O nome de usuário informado é inválido."</string>
 </resources>
diff --git a/car-settings-lib/res/values-ro/strings.xml b/car-settings-lib/res/values-ro/strings.xml
index b33214b..b79ede1 100644
--- a/car-settings-lib/res/values-ro/strings.xml
+++ b/car-settings-lib/res/values-ro/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Sugerate"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Toate limbile"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Câmpul trebuie completat."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Numele de utilizator introdus este nevalid."</string>
 </resources>
diff --git a/car-settings-lib/res/values-ru/strings.xml b/car-settings-lib/res/values-ru/strings.xml
index 3ee4775..d5f064c 100644
--- a/car-settings-lib/res/values-ru/strings.xml
+++ b/car-settings-lib/res/values-ru/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Рекомендуемые"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Все языки"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Поле должно быть заполнено."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Указано недопустимое имя пользователя."</string>
 </resources>
diff --git a/car-settings-lib/res/values-si/strings.xml b/car-settings-lib/res/values-si/strings.xml
index 7b6914b..79e83f7 100644
--- a/car-settings-lib/res/values-si/strings.xml
+++ b/car-settings-lib/res/values-si/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"යෝජිත"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"සියලු භාෂා"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"ක්ෂේත්‍රය හිස් විය නොහැක."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"ඇතුළු කළ පරිශීලක නාමය අවලංගුය."</string>
 </resources>
diff --git a/car-settings-lib/res/values-sk/strings.xml b/car-settings-lib/res/values-sk/strings.xml
index 8caa56c..7bf3819 100644
--- a/car-settings-lib/res/values-sk/strings.xml
+++ b/car-settings-lib/res/values-sk/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Navrhované"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Všetky jazyky"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Pole nesmie byť prázdne."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Zadané používateľské meno je neplatné."</string>
 </resources>
diff --git a/car-settings-lib/res/values-sl/strings.xml b/car-settings-lib/res/values-sl/strings.xml
index b11b8a4..5f46458 100644
--- a/car-settings-lib/res/values-sl/strings.xml
+++ b/car-settings-lib/res/values-sl/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Predlagano"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Vsi jeziki"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Polje ne sme biti prazno."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Vneseno uporabniško ime ni veljavno."</string>
 </resources>
diff --git a/car-settings-lib/res/values-sq/strings.xml b/car-settings-lib/res/values-sq/strings.xml
index ad4a86b..18cbe0f 100644
--- a/car-settings-lib/res/values-sq/strings.xml
+++ b/car-settings-lib/res/values-sq/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Sugjeruar"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Të gjitha gjuhët"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Fusha nuk mund të lihet bosh."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Emri i përdoruesit që fute është i pavlefshëm."</string>
 </resources>
diff --git a/car-settings-lib/res/values-sr/strings.xml b/car-settings-lib/res/values-sr/strings.xml
index 3c1a278..46b5008 100644
--- a/car-settings-lib/res/values-sr/strings.xml
+++ b/car-settings-lib/res/values-sr/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Предложени"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Сви језици"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Поље не сме да буде празно."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Корисничко име које сте унели је неважеће."</string>
 </resources>
diff --git a/car-settings-lib/res/values-sv/strings.xml b/car-settings-lib/res/values-sv/strings.xml
index fdda4e8..d9e2309 100644
--- a/car-settings-lib/res/values-sv/strings.xml
+++ b/car-settings-lib/res/values-sv/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Förslag"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Alla språk"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Fältet får inte vara tomt."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Du har angett ett ogiltigt användarnamn."</string>
 </resources>
diff --git a/car-settings-lib/res/values-sw/strings.xml b/car-settings-lib/res/values-sw/strings.xml
index c930c4b..dbe4958 100644
--- a/car-settings-lib/res/values-sw/strings.xml
+++ b/car-settings-lib/res/values-sw/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Zinazopendekezwa"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Lugha zote"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Ni lazima ujaze sehemu hii"</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Jina uliloweka la mtumiaji si sahihi."</string>
 </resources>
diff --git a/car-settings-lib/res/values-ta/strings.xml b/car-settings-lib/res/values-ta/strings.xml
index 67c76aa..e21d564 100644
--- a/car-settings-lib/res/values-ta/strings.xml
+++ b/car-settings-lib/res/values-ta/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"பரிந்துரைகள்"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"எல்லா மொழிகளும்"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"புலம், வெறுமையாக இருக்கக்கூடாது."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"பயனர்பெயரைத் தவறாக உள்ளிட்டுள்ளீர்கள்."</string>
 </resources>
diff --git a/car-settings-lib/res/values-te/strings.xml b/car-settings-lib/res/values-te/strings.xml
index febfb7d..38b470d 100644
--- a/car-settings-lib/res/values-te/strings.xml
+++ b/car-settings-lib/res/values-te/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"సూచించినవి"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"అన్ని భాషలు"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"ఫీల్డ్ ఖాళీగా ఉండరాదు."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"నమోదు చేసిన వినియోగదారు పేరు చెల్లదు."</string>
 </resources>
diff --git a/car-settings-lib/res/values-th/strings.xml b/car-settings-lib/res/values-th/strings.xml
index 2bdd83c..10ac43a 100644
--- a/car-settings-lib/res/values-th/strings.xml
+++ b/car-settings-lib/res/values-th/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"แนะนำ"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"ทุกภาษา"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"ต้องกรอกข้อมูลในช่อง"</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"ชื่อผู้ใช้ที่ป้อนไม่ถูกต้อง"</string>
 </resources>
diff --git a/car-settings-lib/res/values-tl/strings.xml b/car-settings-lib/res/values-tl/strings.xml
index 0fe6aa8..852721f 100644
--- a/car-settings-lib/res/values-tl/strings.xml
+++ b/car-settings-lib/res/values-tl/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Iminumungkahi"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Lahat ng wika"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Hindi maaaring blangko ang field."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Invalid ang inilagay na username."</string>
 </resources>
diff --git a/car-settings-lib/res/values-tr/strings.xml b/car-settings-lib/res/values-tr/strings.xml
index be77686..bb7499e 100644
--- a/car-settings-lib/res/values-tr/strings.xml
+++ b/car-settings-lib/res/values-tr/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Önerilen"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Tüm diller"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Alan boş olamaz."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Girilen kullanıcı adı geçersiz."</string>
 </resources>
diff --git a/car-settings-lib/res/values-uk/strings.xml b/car-settings-lib/res/values-uk/strings.xml
index bbdb513..4429605 100644
--- a/car-settings-lib/res/values-uk/strings.xml
+++ b/car-settings-lib/res/values-uk/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Пропонується"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Усі мови"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Поле не може бути порожнім."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Введене ім’я користувача недійсне."</string>
 </resources>
diff --git a/car-settings-lib/res/values-ur/strings.xml b/car-settings-lib/res/values-ur/strings.xml
index 9a2bc6a..64f8d4a 100644
--- a/car-settings-lib/res/values-ur/strings.xml
+++ b/car-settings-lib/res/values-ur/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"تجویز کردہ"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"سبھی زبانیں"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"فیلڈ خالی نہیں رہ سکتی۔"</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"درج کردہ صارف نام غلط ہے۔"</string>
 </resources>
diff --git a/car-settings-lib/res/values-uz/strings.xml b/car-settings-lib/res/values-uz/strings.xml
index b4ff1d5..1947548 100644
--- a/car-settings-lib/res/values-uz/strings.xml
+++ b/car-settings-lib/res/values-uz/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Taklif qilingan"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Barcha tillar"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Maydon bo‘sh qoldirilishi mumkin emas."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Kiritilgan foydalanuvchi nomi xato."</string>
 </resources>
diff --git a/car-settings-lib/res/values-vi/strings.xml b/car-settings-lib/res/values-vi/strings.xml
index 1076303..6dbc7d7 100644
--- a/car-settings-lib/res/values-vi/strings.xml
+++ b/car-settings-lib/res/values-vi/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Ðược đề xuất"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Tất cả ngôn ngữ"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Không được để trống trường."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Tên người dùng đã nhập là không hợp lệ."</string>
 </resources>
diff --git a/car-settings-lib/res/values-zh-rCN/strings.xml b/car-settings-lib/res/values-zh-rCN/strings.xml
index 0c98ab9..f9462c5 100644
--- a/car-settings-lib/res/values-zh-rCN/strings.xml
+++ b/car-settings-lib/res/values-zh-rCN/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"建议"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"所有语言"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"此字段不能留空。"</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"输入的用户名无效。"</string>
 </resources>
diff --git a/car-settings-lib/res/values-zh-rHK/strings.xml b/car-settings-lib/res/values-zh-rHK/strings.xml
index 5f5af7c..8c5d191 100644
--- a/car-settings-lib/res/values-zh-rHK/strings.xml
+++ b/car-settings-lib/res/values-zh-rHK/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"建議"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"所有語言"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"欄位不得留空。"</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"輸入的使用者名稱無效。"</string>
 </resources>
diff --git a/car-settings-lib/res/values-zh-rTW/strings.xml b/car-settings-lib/res/values-zh-rTW/strings.xml
index 5f5af7c..8e9c84a 100644
--- a/car-settings-lib/res/values-zh-rTW/strings.xml
+++ b/car-settings-lib/res/values-zh-rTW/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"建議"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"所有語言"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"欄位不能空白。"</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"輸入的使用者名稱無效。"</string>
 </resources>
diff --git a/car-settings-lib/res/values-zu/strings.xml b/car-settings-lib/res/values-zu/strings.xml
index 7d4adba..2e55b3f 100644
--- a/car-settings-lib/res/values-zu/strings.xml
+++ b/car-settings-lib/res/values-zu/strings.xml
@@ -19,4 +19,6 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="language_picker_list_suggested_header" msgid="8931437200168779395">"Okuphakanyisiwe"</string>
     <string name="language_picker_list_all_header" msgid="3907663373765943630">"Zonke izilimi"</string>
+    <string name="name_input_blank_error" msgid="5460631644831377461">"Inkundla ayikwazi ukungabi nalutho."</string>
+    <string name="name_input_invalid_error" msgid="8735081597199782922">"Igama lomsebenzisi elifakiwe alivumelekile."</string>
 </resources>
diff --git a/car-settings-lib/tests/robotests/Android.mk b/car-settings-lib/tests/robotests/Android.mk
index ef813dc..59e61b2 100644
--- a/car-settings-lib/tests/robotests/Android.mk
+++ b/car-settings-lib/tests/robotests/Android.mk
@@ -1,8 +1,8 @@
 LOCAL_PATH := $(call my-dir)
 
-############################################################
-# CarSettingsLib app just for Robolectric test target.     #
-############################################################
+##################################################################
+# Car Settings Library app just for Robolectric test target.     #
+##################################################################
 include $(CLEAR_VARS)
 
 LOCAL_RESOURCE_DIR := $(LOCAL_PATH)/res
@@ -20,18 +20,18 @@
 
 include $(BUILD_PACKAGE)
 
-################################################
-# Car SettingsLibrary Robolectric test target. #
-################################################
+##################################################################
+# Car Settings Library Robolectric test target.                  #
+##################################################################
 include $(CLEAR_VARS)
 
 LOCAL_MODULE := CarSettingsLibRoboTests
+LOCAL_MODULE_CLASS := JAVA_LIBRARIES
 
 LOCAL_SRC_FILES := $(call all-java-files-under, src)
 
 LOCAL_JAVA_RESOURCE_DIRS := config
 
-# Include the testing libraries
 LOCAL_JAVA_LIBRARIES := \
     robolectric_android-all-stub \
     Robolectric_all-target \
@@ -43,6 +43,9 @@
 
 LOCAL_MODULE_TAGS := optional
 
+# Generate test_config.properties
+include external/robolectric-shadows/gen_test_config.mk
+
 include $(BUILD_STATIC_JAVA_LIBRARY)
 
 ##################################################################
diff --git a/car-settings-lib/tests/robotests/config/robolectric.properties b/car-settings-lib/tests/robotests/config/robolectric.properties
index 6a233c1..3626c87 100644
--- a/car-settings-lib/tests/robotests/config/robolectric.properties
+++ b/car-settings-lib/tests/robotests/config/robolectric.properties
@@ -13,5 +13,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-manifest=packages/apps/Car/libs/car-settings-lib/tests/robotests/AndroidManifest.xml
 sdk=NEWEST_SDK
\ No newline at end of file
diff --git a/car-settings-lib/tests/robotests/src/com/android/car/settingslib/log/LoggerBaseTest.java b/car-settings-lib/tests/robotests/src/com/android/car/settingslib/log/LoggerBaseTest.java
index 1fbda08..468c010 100644
--- a/car-settings-lib/tests/robotests/src/com/android/car/settingslib/log/LoggerBaseTest.java
+++ b/car-settings-lib/tests/robotests/src/com/android/car/settingslib/log/LoggerBaseTest.java
@@ -16,17 +16,16 @@
 
 package com.android.car.settingslib.log;
 
-import com.android.car.settingslib.robolectric.CarSettingsLibRobolectricTestRunner;
-
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
 import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
 
 /**
  * Tests {@link LoggerBase}
  */
-@RunWith(CarSettingsLibRobolectricTestRunner.class)
+@RunWith(RobolectricTestRunner.class)
 public class LoggerBaseTest {
 
     @Rule
diff --git a/car-settings-lib/tests/robotests/src/com/android/car/settingslib/robolectric/BaseRobolectricTest.java b/car-settings-lib/tests/robotests/src/com/android/car/settingslib/robolectric/BaseRobolectricTest.java
index ccadbbe..280faea 100644
--- a/car-settings-lib/tests/robotests/src/com/android/car/settingslib/robolectric/BaseRobolectricTest.java
+++ b/car-settings-lib/tests/robotests/src/com/android/car/settingslib/robolectric/BaseRobolectricTest.java
@@ -18,14 +18,12 @@
 import org.junit.Rule;
 import org.mockito.junit.MockitoJUnit;
 import org.mockito.junit.MockitoRule;
-import org.robolectric.annotation.Config;
 
 /**
- * Base test for CarSettingsLib Robolectric tests that sets the manifest and sdk config parameters
+ * Base test for CarSettingsLib Robolectric tests.
  */
-@Config(packageName = "com.android.car.settingslib")
 public abstract class BaseRobolectricTest {
-    //This rule automatically initializes any mocks created using the @Mock annotation
+    // This rule automatically initializes any mocks created using the @Mock annotation
     @Rule
     public MockitoRule mMockitoRule = MockitoJUnit.rule();
 }
diff --git a/car-settings-lib/tests/robotests/src/com/android/car/settingslib/robolectric/CarSettingsLibRobolectricTestRunner.java b/car-settings-lib/tests/robotests/src/com/android/car/settingslib/robolectric/CarSettingsLibRobolectricTestRunner.java
deleted file mode 100644
index 0498c3d..0000000
--- a/car-settings-lib/tests/robotests/src/com/android/car/settingslib/robolectric/CarSettingsLibRobolectricTestRunner.java
+++ /dev/null
@@ -1,108 +0,0 @@
-/*
- * Copyright (C) 2018 Google Inc.
- *
- * 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.car.settingslib.robolectric;
-
-import androidx.annotation.NonNull;
-
-import org.junit.runners.model.InitializationError;
-import org.robolectric.RobolectricTestRunner;
-import org.robolectric.annotation.Config;
-import org.robolectric.manifest.AndroidManifest;
-import org.robolectric.res.Fs;
-import org.robolectric.res.ResourcePath;
-
-import java.net.MalformedURLException;
-import java.net.URL;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-/**
- * Custom test runner for the testing of CarSettingsLib. This is needed because the
- * default behavior for robolectric is just to grab the resource directory in the target package.
- * We want to override this to add several spanning different projects.
- */
-public class CarSettingsLibRobolectricTestRunner extends RobolectricTestRunner {
-    private static final Map<String, String> AAR_VERSIONS;
-    private static final String SUPPORT_RESOURCE_PATH_TEMPLATE =
-            "jar:file:prebuilts/sdk/current/androidx/m2repository/androidx/"
-                    + "%1$s/%1$s/%2$s/%1$s-%2$s.aar!/res";
-
-    static {
-        AAR_VERSIONS = new HashMap<>();
-        AAR_VERSIONS.put("car", "1.0.0-alpha6");
-        AAR_VERSIONS.put("appcompat", "1.1.0-alpha01");
-    }
-
-    /**
-     * We don't actually want to change this behavior, so we just call super.
-     */
-    public CarSettingsLibRobolectricTestRunner(Class<?> testClass) throws InitializationError {
-        super(testClass);
-    }
-
-    private static ResourcePath createResourcePath(@NonNull String filePath) {
-        try {
-            return new ResourcePath(null, Fs.fromURL(new URL(filePath)), null);
-        } catch (MalformedURLException e) {
-            throw new RuntimeException("CarSettingsLibRobolectricTestRunner failure", e);
-        }
-    }
-
-    /**
-     * Create the resource path for a support library component's JAR.
-     */
-    private static String createSupportResourcePathFromJar(@NonNull String componentId) {
-        if (!AAR_VERSIONS.containsKey(componentId)) {
-            throw new IllegalArgumentException("Unknown component " + componentId
-                    + ". Update test with appropriate component name and version.");
-        }
-        return String.format(SUPPORT_RESOURCE_PATH_TEMPLATE, componentId,
-                AAR_VERSIONS.get(componentId));
-    }
-
-    /**
-     * We are going to create our own custom manifest so that we can add multiple resource
-     * paths to it. This lets us access resources in both Settings and SettingsLib in our tests.
-     */
-    @Override
-    protected AndroidManifest getAppManifest(Config config) {
-        // Using the manifest file's relative path, we can figure out the application directory.
-        final String appRoot = "packages/apps/Car/libs/car-settings-lib/";
-        final String manifestPath = appRoot + "/AndroidManifest.xml";
-        final String resDir = appRoot + "/res";
-        final String assetsDir = appRoot + config.assetDir();
-
-        // By adding any resources from libraries we need to the AndroidManifest, we can access
-        // them from within the parallel universe's resource loader.
-        final AndroidManifest manifest = new AndroidManifest(Fs.fileFromPath(manifestPath),
-                Fs.fileFromPath(resDir), Fs.fileFromPath(assetsDir)) {
-            @Override
-            public List<ResourcePath> getIncludedResourcePaths() {
-                List<ResourcePath> paths = super.getIncludedResourcePaths();
-                paths.add(createResourcePath("file:packages/apps/Car/libs/car-settings-lib/res"));
-
-                // Support library resources. These need to point to the prebuilts of support
-                // library and not the source.
-                paths.add(createResourcePath(createSupportResourcePathFromJar("appcompat")));
-                paths.add(createResourcePath(createSupportResourcePathFromJar("car")));
-                return paths;
-            }
-        };
-
-        return manifest;
-    }
-}
diff --git a/car-telephony-common/res/values-af/strings.xml b/car-telephony-common/res/values-af/strings.xml
new file mode 100644
index 0000000..7e19555
--- /dev/null
+++ b/car-telephony-common/res/values-af/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Onbekend"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Stemboodskap"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Koppel tans …"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Bel tans …"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"Hou aan"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Oproep beëindig"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Gekoppel"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Lui tans …"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Ontkoppel tans …"</string>
+</resources>
diff --git a/car-telephony-common/res/values-am/strings.xml b/car-telephony-common/res/values-am/strings.xml
new file mode 100644
index 0000000..6d0315e
--- /dev/null
+++ b/car-telephony-common/res/values-am/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"ያልታወቀ"</string>
+    <string name="voicemail" msgid="2125552157407909509">"የድምፅ መልዕክት"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"በመገናኘት ላይ…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"በመደወል ላይ"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"ያዝናቆይ"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"ጥሪ አብቅቷል"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"ተገናኝቷል"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"በመጥራት ላይ…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"ግንኝነትን በማቋረጥ ላይ…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-ar/strings.xml b/car-telephony-common/res/values-ar/strings.xml
new file mode 100644
index 0000000..fcc72fb
--- /dev/null
+++ b/car-telephony-common/res/values-ar/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"المتّصِل غير معروف."</string>
+    <string name="voicemail" msgid="2125552157407909509">"البريد الصوتي"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"جارٍ الاتصال…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"جارٍ طلب الرقم…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"قيد الانتظار"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"انتهت المكالمة"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"متّصل"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"جارٍ إطلاق الرنين…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"جارٍ قطع الاتصال…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-as/strings.xml b/car-telephony-common/res/values-as/strings.xml
new file mode 100644
index 0000000..a4c90ae
--- /dev/null
+++ b/car-telephony-common/res/values-as/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"অজ্ঞাত"</string>
+    <string name="voicemail" msgid="2125552157407909509">"ভইচমেইল"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"সংযোগ কৰি থকা হৈছে…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"ডায়েল কৰি থকা হৈছে…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"হ’ল্ডত আছে"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"কল শেষ হৈছে"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"সংযোগ কৰা হ’ল"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"ৰিং কৰি আছে…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"সংযোগ ছেদ হৈ আছে…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-az/strings.xml b/car-telephony-common/res/values-az/strings.xml
new file mode 100644
index 0000000..d29aeab
--- /dev/null
+++ b/car-telephony-common/res/values-az/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Naməlum"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Səsli poçt"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Qoşulur…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Nömrə yığılır…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"Gözləmədə"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Zəng sona çatdı"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Qoşuldu"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Zəng çalır…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Bağlantı kəsilir…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-b+sr+Latn/strings.xml b/car-telephony-common/res/values-b+sr+Latn/strings.xml
new file mode 100644
index 0000000..d05ef72
--- /dev/null
+++ b/car-telephony-common/res/values-b+sr+Latn/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Nepoznato"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Govorna pošta"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Povezuje se…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Poziva se…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"Na čekanju"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Poziv je završen"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Povezan"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Zvoni…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Prekida se veza…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-be/strings.xml b/car-telephony-common/res/values-be/strings.xml
new file mode 100644
index 0000000..1e1bcdf
--- /dev/null
+++ b/car-telephony-common/res/values-be/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Невядома"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Галасавая пошта"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Ідзе падключэнне…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Ідзе набор нумара…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"На ўтрыманні"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Выклік скончаны"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Падключана"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Ідзе празвон…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Ідзе адключэнне…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-bg/strings.xml b/car-telephony-common/res/values-bg/strings.xml
new file mode 100644
index 0000000..1f38d61
--- /dev/null
+++ b/car-telephony-common/res/values-bg/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Неизвестно"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Гласова поща"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Свързва се…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Набира се…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"Задържано"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Обаждането завърши"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Установена е връзка"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Звъни се…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Връзката се прекр…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-bn/strings.xml b/car-telephony-common/res/values-bn/strings.xml
new file mode 100644
index 0000000..4855b6e
--- /dev/null
+++ b/car-telephony-common/res/values-bn/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"অজানা"</string>
+    <string name="voicemail" msgid="2125552157407909509">"ভয়েসমেল"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"কানেক্ট হচ্ছে…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"ডায়াল করা হচ্ছে…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"হোল্ডে আছে"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"কল শেষ হয়েছে"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"কানেক্ট করা হয়েছে"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"রিং হচ্ছে…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"ডিসকানেক্ট করা হচ্ছে…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-bs/strings.xml b/car-telephony-common/res/values-bs/strings.xml
new file mode 100644
index 0000000..1d6a8b8
--- /dev/null
+++ b/car-telephony-common/res/values-bs/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Nepoznat"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Govorna pošta"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Povezivanje…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Biranje…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"Na čekanju"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Poziv je završen"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Povezan"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Zvoni…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Prekidanje veze…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-ca/strings.xml b/car-telephony-common/res/values-ca/strings.xml
new file mode 100644
index 0000000..356f31c
--- /dev/null
+++ b/car-telephony-common/res/values-ca/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Desconegut"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Missatge de veu"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"S\'està connectant…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"S\'està marcant…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"En espera"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Trucada finalitzada"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Connectat"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Està sonant…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"S\'està desconnectant…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-cs/strings.xml b/car-telephony-common/res/values-cs/strings.xml
new file mode 100644
index 0000000..41a29b5
--- /dev/null
+++ b/car-telephony-common/res/values-cs/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Neznámé"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Hlasová schránka"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Připojování…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Vytáčení…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"Podrženo"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Hovor byl ukončen"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Připojeno"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Vyzvánění…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Odpojování…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-da/strings.xml b/car-telephony-common/res/values-da/strings.xml
new file mode 100644
index 0000000..dcd52a0
--- /dev/null
+++ b/car-telephony-common/res/values-da/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Ukendt"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Talebesked"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Tilslutter…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Ringer op…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"Afventer"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Opkaldet er slut"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Der er forbindelse"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Ringer…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Afbryder…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-de/strings.xml b/car-telephony-common/res/values-de/strings.xml
new file mode 100644
index 0000000..a5257d3
--- /dev/null
+++ b/car-telephony-common/res/values-de/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Unbekannt"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Mailbox"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Verbinden…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Rufaufbau…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"Warten"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Anruf beendet"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Verbunden"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Klingelt…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Verbindung wird getrennt…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-el/strings.xml b/car-telephony-common/res/values-el/strings.xml
new file mode 100644
index 0000000..40d1716
--- /dev/null
+++ b/car-telephony-common/res/values-el/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Άγνωστη"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Αυτόματος τηλεφωνητής"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Σύνδεση…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Κλήση…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"Σε αναμονή"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Η κλήση τερματίστηκε"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Συνδέθηκε"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Κλήση…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Αποσύνδεση…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-en-rAU/strings.xml b/car-telephony-common/res/values-en-rAU/strings.xml
new file mode 100644
index 0000000..06d1973
--- /dev/null
+++ b/car-telephony-common/res/values-en-rAU/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Unknown"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Voicemail"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Connecting…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Dialling…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"On Hold"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Call Ended"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Connected"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Ringing…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Disconnecting…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-en-rCA/strings.xml b/car-telephony-common/res/values-en-rCA/strings.xml
new file mode 100644
index 0000000..06d1973
--- /dev/null
+++ b/car-telephony-common/res/values-en-rCA/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Unknown"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Voicemail"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Connecting…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Dialling…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"On Hold"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Call Ended"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Connected"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Ringing…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Disconnecting…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-en-rGB/strings.xml b/car-telephony-common/res/values-en-rGB/strings.xml
new file mode 100644
index 0000000..06d1973
--- /dev/null
+++ b/car-telephony-common/res/values-en-rGB/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Unknown"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Voicemail"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Connecting…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Dialling…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"On Hold"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Call Ended"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Connected"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Ringing…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Disconnecting…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-en-rIN/strings.xml b/car-telephony-common/res/values-en-rIN/strings.xml
new file mode 100644
index 0000000..06d1973
--- /dev/null
+++ b/car-telephony-common/res/values-en-rIN/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Unknown"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Voicemail"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Connecting…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Dialling…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"On Hold"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Call Ended"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Connected"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Ringing…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Disconnecting…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-en-rXC/strings.xml b/car-telephony-common/res/values-en-rXC/strings.xml
new file mode 100644
index 0000000..b80f8fa
--- /dev/null
+++ b/car-telephony-common/res/values-en-rXC/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‏‎‏‎‏‏‎‎‏‏‏‎‏‏‏‏‎‏‏‎‏‎‎‏‏‎‎‏‎‏‏‎‎‏‏‎‏‎‏‏‏‎‎‎‏‏‎‏‎‏‎‎‏‏‎‎‎‏‏‎‏‎‎‏‎Unknown‎‏‎‎‏‎"</string>
+    <string name="voicemail" msgid="2125552157407909509">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‎‏‏‏‏‎‏‎‏‏‏‏‏‏‏‎‏‏‏‏‎‏‎‎‏‏‎‏‏‎‎‏‏‏‎‏‏‎‏‏‏‎‏‏‏‎‏‎‎‎‏‎‏‏‎‏‎‎‎‎‏‎‏‎Voicemail‎‏‎‎‏‎"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‏‏‏‎‎‎‎‎‎‏‎‎‎‏‏‏‏‏‎‎‏‏‏‎‎‏‏‏‏‏‎‎‎‎‏‏‎‎‎‎‏‏‎‎‏‎‎‏‎‎‎‏‏‏‏‏‏‏‎‎‎‎‏‎‏‎‎‏‎‎‏‏‎<xliff:g id="LABEL">%1$s</xliff:g>‎‏‎‎‏‏‏‎  ·  ‎‏‎‎‏‏‎<xliff:g id="DURATION">%2$s</xliff:g>‎‏‎‎‏‏‏‎‎‏‎‎‏‎"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‏‏‏‎‏‎‎‏‎‎‏‎‎‏‏‏‎‎‎‏‎‏‎‏‎‏‎‏‏‏‏‎‎‎‎‎‎‏‎‎‎‎‏‎‏‎‎‎‏‎‏‏‎‏‏‏‏‏‎‎‏‎‎‏‎‎Connecting…‎‏‎‎‏‎"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‎‏‏‎‏‎‏‎‏‎‎‏‎‏‏‏‏‏‏‏‏‏‎‎‏‏‏‎‎‏‏‏‏‏‎‎‎‏‎‎‎‎‎‎‏‏‏‏‏‏‎‎‏‎‎‏‎‏‏‎‎‏‎‎Dialing…‎‏‎‎‏‎"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‏‏‏‎‏‏‏‏‎‏‏‎‏‎‏‏‏‎‏‎‏‏‎‎‎‎‏‎‏‏‎‎‏‏‏‏‎‏‏‎‎‎‎‏‏‏‎‏‎‏‏‎‎‎‎‎‎‏‏‏‎‎‏‎‎‎On Hold‎‏‎‎‏‎"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‏‎‏‏‏‎‎‏‏‎‏‏‏‎‎‎‏‏‏‏‏‎‏‎‎‏‏‎‏‎‏‏‏‏‏‏‏‏‎‏‏‎‎‏‏‎‏‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‎‏‎Call Ended‎‏‎‎‏‎"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‏‎‏‎‎‏‏‎‎‏‏‎‏‏‏‏‏‏‎‎‎‎‎‏‎‏‎‎‎‎‎‏‏‎‏‎‏‎‏‏‏‏‏‏‎‎‎‎‏‏‎‎‏‏‎‎‎‎‎‎‏‎‏‎‎Connected‎‏‎‎‏‎"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‏‏‏‎‎‎‎‎‎‎‎‎‏‏‎‎‏‎‏‎‎‏‎‎‏‎‎‏‏‏‎‎‏‎‎‏‏‏‎‎‎‎‏‏‏‎‏‎‏‏‏‏‏‏‏‏‏‎‏‏‎‏‎‎‏‎Ringing…‎‏‎‎‏‎"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‏‏‏‏‏‎‎‎‏‎‏‏‏‏‎‏‎‎‎‏‏‎‎‏‎‏‎‎‎‎‎‏‏‏‏‎‎‏‏‏‎‏‎‎‏‎‎‏‏‏‎‏‏‏‏‎‎‎‏‏‏‏‏‎‏‏‏‎Disconnecting…‎‏‎‎‏‎"</string>
+</resources>
diff --git a/car-telephony-common/res/values-es-rUS/strings.xml b/car-telephony-common/res/values-es-rUS/strings.xml
new file mode 100644
index 0000000..2e71140
--- /dev/null
+++ b/car-telephony-common/res/values-es-rUS/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Desconocido"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Buzón de voz"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Conectando…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Marcando…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"En espera"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Llamada finalizada"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Conectado"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Sonando…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Desconectando…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-es/strings.xml b/car-telephony-common/res/values-es/strings.xml
new file mode 100644
index 0000000..390354f
--- /dev/null
+++ b/car-telephony-common/res/values-es/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Desconocida"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Buzón de voz"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Conectando…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Marcando…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"En espera"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Llamada finalizada"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Conectado"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Sonando…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Desconectando…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-et/strings.xml b/car-telephony-common/res/values-et/strings.xml
new file mode 100644
index 0000000..ee65909
--- /dev/null
+++ b/car-telephony-common/res/values-et/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Tundmatu"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Kõnepost"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Ühendamine …"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Valimine …"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"Ootel"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Kõne lõpetati"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Ühendatud"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Heliseb …"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Ühenduse katkest. …"</string>
+</resources>
diff --git a/car-telephony-common/res/values-eu/strings.xml b/car-telephony-common/res/values-eu/strings.xml
new file mode 100644
index 0000000..ddaec85
--- /dev/null
+++ b/car-telephony-common/res/values-eu/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Ezezaguna"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Erantzungailua"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Konektatzen…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Markatzen…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"Zain"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Deia amaituta"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Konektatuta"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Deitzen…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Deskonektatzen…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-fa/strings.xml b/car-telephony-common/res/values-fa/strings.xml
new file mode 100644
index 0000000..092b944
--- /dev/null
+++ b/car-telephony-common/res/values-fa/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"نامشخص"</string>
+    <string name="voicemail" msgid="2125552157407909509">"پست صوتی"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"درحال اتصال…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"درحال شماره‌گیری"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"در انتظار"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"تماس پایان یافت"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"متصل"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"درحال زنگ زدن…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"درحال قطع اتصال…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-fi/strings.xml b/car-telephony-common/res/values-fi/strings.xml
new file mode 100644
index 0000000..ce6ff53
--- /dev/null
+++ b/car-telephony-common/res/values-fi/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Tuntematon"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Vastaaja"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Yhdistetään…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Soitetaan…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"Pidossa"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Puhelu päättyi"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Yhdistetty"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Soi…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Katkaistaan…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-fr-rCA/strings.xml b/car-telephony-common/res/values-fr-rCA/strings.xml
new file mode 100644
index 0000000..cef9278
--- /dev/null
+++ b/car-telephony-common/res/values-fr-rCA/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Inconnu"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Messagerie vocale"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g> : <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Connexion en cours…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Composition…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"En attente"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Appel terminé"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Connecté"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Sonnerie en cours…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Déconnexion…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-fr/strings.xml b/car-telephony-common/res/values-fr/strings.xml
new file mode 100644
index 0000000..164f23d
--- /dev/null
+++ b/car-telephony-common/res/values-fr/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Inconnu"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Messagerie vocale"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Connexion…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Composition numéro…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"En attente"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Appel terminé"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Appel en cours"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Sonnerie…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Déconnexion…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-gl/strings.xml b/car-telephony-common/res/values-gl/strings.xml
new file mode 100644
index 0000000..2251c16
--- /dev/null
+++ b/car-telephony-common/res/values-gl/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Descoñecido"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Correo de voz"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Conectando…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Marcando…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"En espera"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Chamada finalizada"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Conectado"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Facendo soar…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Desconectando…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-gu/strings.xml b/car-telephony-common/res/values-gu/strings.xml
new file mode 100644
index 0000000..04cf443
--- /dev/null
+++ b/car-telephony-common/res/values-gu/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"અજાણ"</string>
+    <string name="voicemail" msgid="2125552157407909509">"વૉઇસમેઇલ"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"કનેક્ટ થઈ રહ્યું છે…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"ડાયલ કરી રહ્યાં છે…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"હોલ્ડ પર"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"કૉલ સમાપ્ત થયો"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"કનેક્ટેડ"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"રિંગ વાગી રહી છે…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"ડિસ્કનેક્ટ થાય છે…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-hi/strings.xml b/car-telephony-common/res/values-hi/strings.xml
new file mode 100644
index 0000000..5fdb213
--- /dev/null
+++ b/car-telephony-common/res/values-hi/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"अनजान"</string>
+    <string name="voicemail" msgid="2125552157407909509">"वॉइसमेल"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"कनेक्ट हो रहा है…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"डायल किया जा रहा है…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"कॉल होल्ड पर है"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"कॉल खत्म हो गया"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"जुड़ गया है"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"घंटी बज रही है…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"डिसकनेक्ट हो रहा है…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-hr/strings.xml b/car-telephony-common/res/values-hr/strings.xml
new file mode 100644
index 0000000..5e0f4d7
--- /dev/null
+++ b/car-telephony-common/res/values-hr/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Nepoznato"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Govorna pošta"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Povezivanje…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Biranje broja…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"Na čekanju"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Poziv je završio"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Povezano"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Zvonjenje…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Isključivanje…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-hu/strings.xml b/car-telephony-common/res/values-hu/strings.xml
new file mode 100644
index 0000000..fa95e1a
--- /dev/null
+++ b/car-telephony-common/res/values-hu/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Ismeretlen"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Hangposta"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Csatlakozás…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Tárcsázás…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"Várakoztatva"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"A hívás befejeződött"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Csatlakozva"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Csörgés…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Kapcsolat bontása…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-hy/strings.xml b/car-telephony-common/res/values-hy/strings.xml
new file mode 100644
index 0000000..c8d7ea9
--- /dev/null
+++ b/car-telephony-common/res/values-hy/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Անհայտ"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Ձայնային փոստ"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Միացում…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Համարհավաքում…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"Սպասում"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Զանգն ավարտվեց"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Միացած է"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Զանգ…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Անջատվում է…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-in/strings.xml b/car-telephony-common/res/values-in/strings.xml
new file mode 100644
index 0000000..53a7831
--- /dev/null
+++ b/car-telephony-common/res/values-in/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Tidak dikenal"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Pesan suara"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Menghubungkan…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Memanggil…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"Harap Tunggu"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Panggilan Diakhiri"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Terhubung"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Berdering…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Memutus hubungan..."</string>
+</resources>
diff --git a/car-telephony-common/res/values-is/strings.xml b/car-telephony-common/res/values-is/strings.xml
new file mode 100644
index 0000000..b91a805
--- /dev/null
+++ b/car-telephony-common/res/values-is/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Óþekkt"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Talhólf"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Tengist…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Hringir…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"Í bið"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Símtali lokið"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Tengt"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Hringir…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Aftengist…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-it/strings.xml b/car-telephony-common/res/values-it/strings.xml
new file mode 100644
index 0000000..cb4bc61
--- /dev/null
+++ b/car-telephony-common/res/values-it/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Sconosciuto"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Segreteria"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Connessione…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Chiamata…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"In attesa"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Chiamata terminata"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Connesso"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Sta squillando…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Disconnessione…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-iw/strings.xml b/car-telephony-common/res/values-iw/strings.xml
new file mode 100644
index 0000000..0d1cd68
--- /dev/null
+++ b/car-telephony-common/res/values-iw/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"לא ידוע"</string>
+    <string name="voicemail" msgid="2125552157407909509">"דואר קולי"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"מתחבר…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"מחייג…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"בהמתנה"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"השיחה הסתיימה"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"מתבצעת שיחה"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"מצלצל…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"מתנתק…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-ja/strings.xml b/car-telephony-common/res/values-ja/strings.xml
new file mode 100644
index 0000000..4c0a6c1
--- /dev/null
+++ b/car-telephony-common/res/values-ja/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"不明"</string>
+    <string name="voicemail" msgid="2125552157407909509">"ボイスメール"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"接続中…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"発信中…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"保留中"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"通話終了"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"接続済み"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"着信中…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"切断中…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-ka/strings.xml b/car-telephony-common/res/values-ka/strings.xml
new file mode 100644
index 0000000..858ffa3
--- /dev/null
+++ b/car-telephony-common/res/values-ka/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"უცნობი"</string>
+    <string name="voicemail" msgid="2125552157407909509">"ხმოვანი ფოსტა"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"დაკავშირება…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"მიმდინარეობს აკრეფა…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"შეყოვნების რეჟიმში"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"ზარი დასრულდა"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"დაკავშირებულია"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"ირეკება…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"კავშირი წყდება…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-kk/strings.xml b/car-telephony-common/res/values-kk/strings.xml
new file mode 100644
index 0000000..48eba3d
--- /dev/null
+++ b/car-telephony-common/res/values-kk/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Белгісіз"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Дауыстық хабар"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Жалғануда…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Терілуде…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"Күтуде"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Қоңырау аяқталды"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Жалғанды"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Шылдырлату…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Ажыратылуда…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-km/strings.xml b/car-telephony-common/res/values-km/strings.xml
new file mode 100644
index 0000000..a483de3
--- /dev/null
+++ b/car-telephony-common/res/values-km/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"មិនស្គាល់"</string>
+    <string name="voicemail" msgid="2125552157407909509">"សារ​ជា​សំឡេង"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"កំពុងភ្ជាប់…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"កំពុងហៅ…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"រង់ចាំ"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"បាន​បញ្ចប់​ការ​ហៅ"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"បានភ្ជាប់"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"កំពុង​រោទ៍…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"កំពុង​ផ្ដាច់…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-kn/strings.xml b/car-telephony-common/res/values-kn/strings.xml
new file mode 100644
index 0000000..7b57804
--- /dev/null
+++ b/car-telephony-common/res/values-kn/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"ಅಪರಿಚಿತ"</string>
+    <string name="voicemail" msgid="2125552157407909509">"ಧ್ವನಿಮೇಲ್"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"ಸಂಪರ್ಕಿಸಲಾಗುತ್ತಿದೆ…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"ಡಯಲ್‌ ಮಾಡಲಾಗುತ್ತಿದೆ…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"ಹೋಲ್ಡ್‌ ಮಾಡಲಾಗಿದೆ"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"ಕರೆ ಅಂತ್ಯಗೊಂಡಿದೆ"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"ಸಂಪರ್ಕಿಸಲಾಗಿದೆ"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"ರಿಂಗ್‍ ಆಗುತ್ತಿದೆ…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"ಸಂಪರ್ಕ ಕಡಿತಗೊಳಿಸಲಾ…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-ko/strings.xml b/car-telephony-common/res/values-ko/strings.xml
new file mode 100644
index 0000000..1171186
--- /dev/null
+++ b/car-telephony-common/res/values-ko/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"알 수 없음"</string>
+    <string name="voicemail" msgid="2125552157407909509">"음성사서함"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"연결 중…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"전화 거는 중..."</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"대기 중"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"통화 종료됨"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"연결됨"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"벨소리 울리는 중…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"연결 해제 중..."</string>
+</resources>
diff --git a/car-telephony-common/res/values-ky/strings.xml b/car-telephony-common/res/values-ky/strings.xml
new file mode 100644
index 0000000..b76e748
--- /dev/null
+++ b/car-telephony-common/res/values-ky/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Белгисиз"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Үн почтасы"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Туташууда…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Терилүүдө…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"Күтүү режиминде"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Чалуу аяктады"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Туташты"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Шыңгырап жатат…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Ажыратылууда…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-lo/strings.xml b/car-telephony-common/res/values-lo/strings.xml
new file mode 100644
index 0000000..b6cc9df
--- /dev/null
+++ b/car-telephony-common/res/values-lo/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"ບໍ່ຮູ້ຈັກ"</string>
+    <string name="voicemail" msgid="2125552157407909509">"ຂໍ້ຄວາມສຽງ"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"ກຳລັງເຊື່ອມຕໍ່…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"ກຳລັງໂທ…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"ຖືສາຍລໍຖ້າ"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"ວາງສາຍແລ້ວ"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"ເຊື່ອມຕໍ່ແລ້ວ"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"ກຳລັງດັງ…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"ກຳລັງຕັດການເຊື່ອມຕໍ່…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-lt/strings.xml b/car-telephony-common/res/values-lt/strings.xml
new file mode 100644
index 0000000..ea0508a
--- /dev/null
+++ b/car-telephony-common/res/values-lt/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Nežinomas"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Balso paštas"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Prisijungiama…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Renkamas numeris…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"Sulaikyta"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Skambutis baigtas"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Sujungta"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Skambinama…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Atsijungiama…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-lv/strings.xml b/car-telephony-common/res/values-lv/strings.xml
new file mode 100644
index 0000000..28e49f5
--- /dev/null
+++ b/car-telephony-common/res/values-lv/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Nezināms"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Balss pasts"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Veido savienojumu…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Sastāda numuru…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"Aizturēts"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Zvans ir pabeigts"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Savienots"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Zvana…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Notiek atvienošana…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-mk/strings.xml b/car-telephony-common/res/values-mk/strings.xml
new file mode 100644
index 0000000..b6053e3
--- /dev/null
+++ b/car-telephony-common/res/values-mk/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Непознат"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Говорна пошта"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Се поврзува…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Бирање…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"На чекање"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Повикот заврши"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Поврзан"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Ѕвони…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Се исклучува…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-ml/strings.xml b/car-telephony-common/res/values-ml/strings.xml
new file mode 100644
index 0000000..e940e9b
--- /dev/null
+++ b/car-telephony-common/res/values-ml/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"അജ്ഞാതം"</string>
+    <string name="voicemail" msgid="2125552157407909509">"വോയ്‌സ്‌മെയിൽ"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"കണക്റ്റ് ചെയ്യുന്നു…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"ഡയൽ ചെയ്യുന്നു…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"ഹോള്‍ഡിലാണ്"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"കോൾ അവസാനിച്ചു"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"കണക്‌റ്റ് ചെയ്‌തു"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"റിംഗ് ചെയ്യുന്നു…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"വിച്ഛേദിക്കുന്നു…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-mn/strings.xml b/car-telephony-common/res/values-mn/strings.xml
new file mode 100644
index 0000000..5fdc776
--- /dev/null
+++ b/car-telephony-common/res/values-mn/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Тодорхойгүй"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Дуут шуудан"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Холбогдож байна…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Залгаж байна…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"Хүлээлгэнд байна"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Дуудлагыг тасалсан"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Холбогдсон"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Дуугарч байна…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Салгаж байна…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-mr/strings.xml b/car-telephony-common/res/values-mr/strings.xml
new file mode 100644
index 0000000..9c7f085
--- /dev/null
+++ b/car-telephony-common/res/values-mr/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"अज्ञात"</string>
+    <string name="voicemail" msgid="2125552157407909509">"व्हॉइसमेल"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"कनेक्ट करत आहे…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"डायल करत आहे…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"होल्ड वर"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"कॉल संपला"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"कनेक्ट केले"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"रिंग होत आहे…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"डिस्कनेक्ट करत आहे…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-ms/strings.xml b/car-telephony-common/res/values-ms/strings.xml
new file mode 100644
index 0000000..1c1d5de
--- /dev/null
+++ b/car-telephony-common/res/values-ms/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Tidak diketahui"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Mel suara"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Menyambung…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Mendail…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"Ditunda"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Panggilan Tamat"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Disambungkan"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Berdering…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Memutuskan sambungn…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-my/strings.xml b/car-telephony-common/res/values-my/strings.xml
new file mode 100644
index 0000000..130935a
--- /dev/null
+++ b/car-telephony-common/res/values-my/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"အမည်မသိ"</string>
+    <string name="voicemail" msgid="2125552157407909509">"အသံမေးလ်"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"ချိတ်ဆက်နေသည်…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"ခေါ်ဆိုနေသည်…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"ဖုန်းကိုင်ထားသည်"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"ခေါ်ဆိုမှု ပြီးပါပြီ"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"ချိတ်ဆက်ထားသည်"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"အသံမြည်နေသည်…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"အဆက်အသွယ် ဖြတ်နေသည်…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-nb/strings.xml b/car-telephony-common/res/values-nb/strings.xml
new file mode 100644
index 0000000..119f352
--- /dev/null
+++ b/car-telephony-common/res/values-nb/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Ukjent"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Talepost"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Kobler til …"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Slår nummeret …"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"På vent"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Anropet er avsluttet"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Tilkoblet"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Ringer …"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Kobler fra …"</string>
+</resources>
diff --git a/car-telephony-common/res/values-ne/strings.xml b/car-telephony-common/res/values-ne/strings.xml
new file mode 100644
index 0000000..b021f11
--- /dev/null
+++ b/car-telephony-common/res/values-ne/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"अज्ञात"</string>
+    <string name="voicemail" msgid="2125552157407909509">"भ्वाइस मेल"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"जोड्दै…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"डायल गर्दै…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"होल्डमा छ"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"कल समाप्त भयो"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"जडान गरिएको छ"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"घन्टी बज्दै छ…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"विच्छेद गर्दै…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-nl/strings.xml b/car-telephony-common/res/values-nl/strings.xml
new file mode 100644
index 0000000..7d00163
--- /dev/null
+++ b/car-telephony-common/res/values-nl/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Onbekend"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Voicemail"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Verbinden…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Kiezen…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"In de wacht"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Gesprek beëindigd"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Verbonden"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Gaat over…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Verb. verbreken…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-or/strings.xml b/car-telephony-common/res/values-or/strings.xml
new file mode 100644
index 0000000..775e33c
--- /dev/null
+++ b/car-telephony-common/res/values-or/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"ଅଜଣା"</string>
+    <string name="voicemail" msgid="2125552157407909509">"ଭଏସ୍‌ମେଲ୍"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"ସଂଯୋଗ ହେଉଛି…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"ଡାଏଲ୍ କରାଯାଉଛି…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"ହୋଲ୍ଡରେ ଅଛି"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"କଲ୍ ସମାପ୍ତ ହେଲା"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"ସଂଯୋଗ ହୋଇଛି"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"ରିଙ୍ଗ ହେଉଛି…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"ବିଚ୍ଛିନ୍ନ ହେଉଛି…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-pa/strings.xml b/car-telephony-common/res/values-pa/strings.xml
new file mode 100644
index 0000000..129276b
--- /dev/null
+++ b/car-telephony-common/res/values-pa/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"ਅਗਿਆਤ"</string>
+    <string name="voicemail" msgid="2125552157407909509">"ਵੌਇਸਮੇਲ"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"ਕਨੈਕਟ ਹੋ ਰਿਹਾ ਹੈ…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"ਡਾਇਲ ਹੋ ਰਿਹਾ ਹੈ…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"ਰੋਕ ਕੇ ਰੱਖੀ ਗਈ"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"ਕਾਲ ਸਮਾਪਤ ਹੋਈ"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"ਕਨੈਕਟ ਹੈ"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"ਘੰਟੀ ਵੱਜ ਰਹੀ ਹੈ…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"ਡਿਸਕਨੈਕਟ ਹੋ ਰਿਹਾ ਹੈ…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-pl/strings.xml b/car-telephony-common/res/values-pl/strings.xml
new file mode 100644
index 0000000..1212857
--- /dev/null
+++ b/car-telephony-common/res/values-pl/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Nieznany numer"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Poczta głosowa"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Łączę…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Wybieram numer…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"Oczekujące"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Koniec połączenia"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Połączono"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Dzwonię…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Rozłączam…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-pt-rPT/strings.xml b/car-telephony-common/res/values-pt-rPT/strings.xml
new file mode 100644
index 0000000..3b518e6
--- /dev/null
+++ b/car-telephony-common/res/values-pt-rPT/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Desconhecido"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Correio de voz"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"A ligar…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"A marcar…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"Em espera"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Chamada terminada"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Ligado"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"A tocar…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"A desligar…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-pt/strings.xml b/car-telephony-common/res/values-pt/strings.xml
new file mode 100644
index 0000000..7531adb
--- /dev/null
+++ b/car-telephony-common/res/values-pt/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Desconhecido"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Correio de voz"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Conectando…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Discando…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"Em espera"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Chamada encerrada"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Conectado"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Tocando…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Desconectando…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-ro/strings.xml b/car-telephony-common/res/values-ro/strings.xml
new file mode 100644
index 0000000..a9883de
--- /dev/null
+++ b/car-telephony-common/res/values-ro/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Necunoscut"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Mesagerie vocală"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Se conectează…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Se apelează…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"În așteptare"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Apel încheiat"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Conectat"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Sună…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Se deconectează…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-ru/strings.xml b/car-telephony-common/res/values-ru/strings.xml
new file mode 100644
index 0000000..2e37211
--- /dev/null
+++ b/car-telephony-common/res/values-ru/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Неизвестный абонент"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Голосовая почта"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Подключение…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Набор номера…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"На удержании"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Вызов завершен"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Подключено"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Вызов…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Отключение…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-si/strings.xml b/car-telephony-common/res/values-si/strings.xml
new file mode 100644
index 0000000..399c8d8
--- /dev/null
+++ b/car-telephony-common/res/values-si/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"නොදනී"</string>
+    <string name="voicemail" msgid="2125552157407909509">"හඬ තැපෑල"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"සබැඳෙමින්…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"අමතමින්…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"රඳවා ඇත"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"ඇමතුම නිමා විය"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"සම්බන්ධයි"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"නාද වෙමින්…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"විසන්ධි වෙමින්…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-sk/strings.xml b/car-telephony-common/res/values-sk/strings.xml
new file mode 100644
index 0000000..83721d3
--- /dev/null
+++ b/car-telephony-common/res/values-sk/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Neznáme"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Hlasová schránka"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Pripája sa…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Vytáča sa…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"Podržané"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Hovor bol ukončený"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Pripojené"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Prezváňa sa…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Odpája sa…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-sl/strings.xml b/car-telephony-common/res/values-sl/strings.xml
new file mode 100644
index 0000000..03a7063
--- /dev/null
+++ b/car-telephony-common/res/values-sl/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Neznano"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Odzivnik"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Povezovanje …"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Klicanje …"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"Zadržan"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Klic je bil končan"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Povezano"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Zvonjenje …"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Prekin. povezave …"</string>
+</resources>
diff --git a/car-telephony-common/res/values-sq/strings.xml b/car-telephony-common/res/values-sq/strings.xml
new file mode 100644
index 0000000..f6439eb
--- /dev/null
+++ b/car-telephony-common/res/values-sq/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"I panjohur"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Posta zanore"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Po lidhet…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Po formon numrin…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"Në pritje"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Telefonata përfundoi"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Lidhur"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Po bie zilja…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Po shkëputet…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-sr/strings.xml b/car-telephony-common/res/values-sr/strings.xml
new file mode 100644
index 0000000..1f3837f
--- /dev/null
+++ b/car-telephony-common/res/values-sr/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Непознато"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Говорна пошта"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Повезује се…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Позива се…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"На чекању"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Позив је завршен"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Повезан"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Звони…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Прекида се веза…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-sv/strings.xml b/car-telephony-common/res/values-sv/strings.xml
new file mode 100644
index 0000000..f4b9b1a
--- /dev/null
+++ b/car-telephony-common/res/values-sv/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Okänd"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Röstbrevlåda"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Ansluter …"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Ringer upp …"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"Parkerat"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Samtal avslutat"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Ansluten"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Ringer …"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Kopplar från …"</string>
+</resources>
diff --git a/car-telephony-common/res/values-sw/strings.xml b/car-telephony-common/res/values-sw/strings.xml
new file mode 100644
index 0000000..f6adbc1
--- /dev/null
+++ b/car-telephony-common/res/values-sw/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Haijulikani"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Ujumbe wa sauti"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Inaunganisha…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Inapigia…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"Inangoja"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Simu Imekamilika"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Imeunganisha"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Inalia…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Inaondoa…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-ta/strings.xml b/car-telephony-common/res/values-ta/strings.xml
new file mode 100644
index 0000000..d835fab
--- /dev/null
+++ b/car-telephony-common/res/values-ta/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"தெரியாதவர்"</string>
+    <string name="voicemail" msgid="2125552157407909509">"குரலஞ்சல்"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"இணைக்கிறது…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"டயல் செய்கிறது…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"காத்திருப்பில்"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"அழைப்பு முடிந்தது"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"இணைக்கப்பட்டது"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"அழைக்கிறது…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"துண்டிக்கிறது…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-te/strings.xml b/car-telephony-common/res/values-te/strings.xml
new file mode 100644
index 0000000..2ebcb08
--- /dev/null
+++ b/car-telephony-common/res/values-te/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"తెలియదు"</string>
+    <string name="voicemail" msgid="2125552157407909509">"వాయిస్ మెయిల్"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"కనెక్ట్ అవుతోంది…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"డయల్ చేస్తోంది…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"హోల్డ్‌లో ఉంది"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"కాల్ ముగిసింది"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"కనెక్ట్ చేయబడింది"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"రింగ్ అవుతోంది…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"డిస్కనెక్టవుతోంది…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-th/strings.xml b/car-telephony-common/res/values-th/strings.xml
new file mode 100644
index 0000000..7af5876
--- /dev/null
+++ b/car-telephony-common/res/values-th/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"ไม่รู้จัก"</string>
+    <string name="voicemail" msgid="2125552157407909509">"ข้อความเสียง"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"กำลังเชื่อมต่อ…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"กำลังโทรออก…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"พักสาย"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"วางสายแล้ว"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"เชื่อมต่อแล้ว"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"กำลังส่งเสียง…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"ยกเลิกการเชื่อมต่อ…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-tl/strings.xml b/car-telephony-common/res/values-tl/strings.xml
new file mode 100644
index 0000000..f5f02ef
--- /dev/null
+++ b/car-telephony-common/res/values-tl/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Hindi Alam"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Voicemail"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Kumokonekta…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Dina-dial…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"Naka-hold"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Natapos ang Tawag"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Nakakonekta"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Nagri-ring…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Dinidiskonekta…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-tr/strings.xml b/car-telephony-common/res/values-tr/strings.xml
new file mode 100644
index 0000000..8da8d62
--- /dev/null
+++ b/car-telephony-common/res/values-tr/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Arayan Bilinmiyor"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Sesli Mesaj"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Bağlanıyor…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Numara çevriliyor…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"Beklemede"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Çağrı Sonlandırıldı"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Bağlandı"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Zil çaldırılıyor…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Bağlantı kesiliyor…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-uk/strings.xml b/car-telephony-common/res/values-uk/strings.xml
new file mode 100644
index 0000000..6c05db2
--- /dev/null
+++ b/car-telephony-common/res/values-uk/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Невідомо"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Голосова пошта"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"З’єднання…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Набір номера…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"Утримується"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Виклик завершено"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Під’єднано"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Дзвінок…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Від’єднання…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-ur/strings.xml b/car-telephony-common/res/values-ur/strings.xml
new file mode 100644
index 0000000..92dfe09
--- /dev/null
+++ b/car-telephony-common/res/values-ur/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"نامعلوم"</string>
+    <string name="voicemail" msgid="2125552157407909509">"صوتی میل"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"منسلک ہو رہا ہے…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"ڈائل کر رہا ہے…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"ہولڈ پر ہے"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"کال ختم ہوگئی"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"منسلک ہے"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"گھنٹی بج رہی ہے…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"غیر منسلک ہو رہا ہے…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-uz/strings.xml b/car-telephony-common/res/values-uz/strings.xml
new file mode 100644
index 0000000..2683304
--- /dev/null
+++ b/car-telephony-common/res/values-uz/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Noaniq"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Ovozli pochta"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Ulanmoqda…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Raqam terilmoqda…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"Kutish holatida"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Chaqiruv yakunlandi"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Ulandi"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Jiringlamoqda…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Uzilmoqda…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-vi/strings.xml b/car-telephony-common/res/values-vi/strings.xml
new file mode 100644
index 0000000..e52194a
--- /dev/null
+++ b/car-telephony-common/res/values-vi/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Không xác định"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Thư thoại"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Đang kết nối…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Đang quay số..."</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"Đang chờ"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Cuộc gọi đã kết thúc"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Đã kết nối"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Đang đổ chuông..."</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Đang ngắt kết nối…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-zh-rCN/strings.xml b/car-telephony-common/res/values-zh-rCN/strings.xml
new file mode 100644
index 0000000..1a6a652
--- /dev/null
+++ b/car-telephony-common/res/values-zh-rCN/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"未知"</string>
+    <string name="voicemail" msgid="2125552157407909509">"语音邮件"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"正在连接…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"正在拨号…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"呼叫等待"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"通话已结束"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"已连接"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"正在响铃…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"正在断开连接…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-zh-rHK/strings.xml b/car-telephony-common/res/values-zh-rHK/strings.xml
new file mode 100644
index 0000000..c92766e
--- /dev/null
+++ b/car-telephony-common/res/values-zh-rHK/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"不明"</string>
+    <string name="voicemail" msgid="2125552157407909509">"留言"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"正在連接…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"正在撥號…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"保留通話"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"通話已結束"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"已連接"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"正在發出鈴聲…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"正在解除連接…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-zh-rTW/strings.xml b/car-telephony-common/res/values-zh-rTW/strings.xml
new file mode 100644
index 0000000..decc1db
--- /dev/null
+++ b/car-telephony-common/res/values-zh-rTW/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"不明"</string>
+    <string name="voicemail" msgid="2125552157407909509">"語音信箱"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"連線中…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"撥號中…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"保留中"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"通話結束"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"已連線"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"鈴響中…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"正在中斷連線…"</string>
+</resources>
diff --git a/car-telephony-common/res/values-zu/strings.xml b/car-telephony-common/res/values-zu/strings.xml
new file mode 100644
index 0000000..0978e00
--- /dev/null
+++ b/car-telephony-common/res/values-zu/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2015 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="unknown" msgid="3237922751873109097">"Akwaziwa"</string>
+    <string name="voicemail" msgid="2125552157407909509">"Ivoyisimeyili"</string>
+    <string name="phone_label_with_info" msgid="4652109530699808645">"<xliff:g id="LABEL">%1$s</xliff:g>  ·  <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="call_state_connecting" msgid="5930724746375294866">"Iyaxhuma…"</string>
+    <string name="call_state_dialing" msgid="1534599871716648114">"Iyadayela…"</string>
+    <string name="call_state_hold" msgid="6834028102796624100">"Ibanjiwe"</string>
+    <string name="call_state_call_ended" msgid="4159349597599886429">"Ikholi iqediwe"</string>
+    <string name="call_state_call_active" msgid="2769644783657864202">"Ixhunyiwe"</string>
+    <string name="call_state_call_ringing" msgid="4618803402954375017">"Iyakhala…"</string>
+    <string name="call_state_call_ending" msgid="5037498349965472247">"Iyanqamula…"</string>
+</resources>
diff --git a/car-theme-lib/Android.bp b/car-theme-lib/Android.bp
new file mode 100644
index 0000000..990148c
--- /dev/null
+++ b/car-theme-lib/Android.bp
@@ -0,0 +1,30 @@
+//
+// 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.
+//
+
+android_library {
+    name: "car-theme-lib-bp",
+
+    srcs: ["src/**/*.java"],
+
+    resource_dirs: ["res"],
+
+    static_libs: ["androidx.car_car"],
+
+    optimize: {
+        enabled: false,
+    },
+
+}
