diff --git a/car-admin-ui-lib/src/main/java/com/android/car/admin/ui/ManagedDeviceTextView.java b/car-admin-ui-lib/src/main/java/com/android/car/admin/ui/ManagedDeviceTextView.java
index 9d2fc49..46b2a2c 100644
--- a/car-admin-ui-lib/src/main/java/com/android/car/admin/ui/ManagedDeviceTextView.java
+++ b/car-admin-ui-lib/src/main/java/com/android/car/admin/ui/ManagedDeviceTextView.java
@@ -70,8 +70,7 @@
             if (DEBUG) {
                 Log.d(TAG, "organization name not set, using device owner app name instead");
             }
-            return res.getString(R.string.car_admin_ui_managed_device_message_by_app,
-                    dpm.getDeviceOwnerNameOnAnyUser());
+            return res.getString(R.string.car_admin_ui_managed_device_message_generic);
         } catch (Exception e) {
             Log.w(TAG, "error getting name of device owner organization", e);
             return res.getString(R.string.car_admin_ui_managed_device_message_generic);
diff --git a/car-admin-ui-lib/src/main/res/values/strings.xml b/car-admin-ui-lib/src/main/res/values/strings.xml
index f03a066..a591e5d 100644
--- a/car-admin-ui-lib/src/main/res/values/strings.xml
+++ b/car-admin-ui-lib/src/main/res/values/strings.xml
@@ -13,11 +13,11 @@
 See the License for the specific language governing permissions and
 limitations under the License.
 -->
-<resources>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
 
-    <!--  TODO(b/175214581): STOPSHIP use proper sentence, remove translatable=false, and document what they mean -->
-    <string name="car_admin_ui_managed_device_message_generic" translatable="false">This device is owned and managed by an enteprise</string>
-    <string name="car_admin_ui_managed_device_message_by_org" translatable="false">This device is owned by and managed by %1$s</string>
-    <string name="car_admin_ui_managed_device_message_by_app" translatable="false">This device is owned by an enterprise and managed by app %1$s</string>
+    <!-- Message displayed in multiple places indicating the device is managed by an organization, but the name of the organization is not known [CHAR LIMIT=NONE]-->
+    <string name="car_admin_ui_managed_device_message_generic">Vehicle managed by an organization</string>
+    <!-- Message displayed in multiple places indicating the device is managed by an organization [CHAR LIMIT=NONE]-->
+    <string name="car_admin_ui_managed_device_message_by_org">Vehicle managed by <xliff:g id="organization name" example="Acme Corporation">%1$s</xliff:g></string>
 
 </resources>
diff --git a/car_product/build/car_base.mk b/car_product/build/car_base.mk
index c0d5190..cbd0b3c 100644
--- a/car_product/build/car_base.mk
+++ b/car_product/build/car_base.mk
@@ -74,7 +74,8 @@
 ifeq ($(ENABLE_EVS_SAMPLE), true)
 # ENABLE_EVS_SAMPLE should set be true or their vendor specific equivalents should be included in
 # the device.mk with the corresponding selinux policies
-PRODUCT_PRODUCT_PROPERTIES += persist.automotive.evs.mode=0
+LOCAL_EVS_PROPERTIES ?= persist.automotive.evs.mode=0
+PRODUCT_PRODUCT_PROPERTIES += $(LOCAL_EVS_PROPERTIES)
 PRODUCT_PACKAGES += evs_app \
                     android.hardware.automotive.evs@1.1-sample \
                     android.frameworks.automotive.display@1.0-service
diff --git a/car_product/car_ui_portrait/rro/CarUiPortraitLauncherRRO/res/values/config.xml b/car_product/car_ui_portrait/rro/CarUiPortraitLauncherRRO/res/values/config.xml
index d049e9b..fa5b133 100644
--- a/car_product/car_ui_portrait/rro/CarUiPortraitLauncherRRO/res/values/config.xml
+++ b/car_product/car_ui_portrait/rro/CarUiPortraitLauncherRRO/res/values/config.xml
@@ -37,4 +37,11 @@
         <item>android.car.cluster/android.car.cluster.MainClusterActivity</item>
         <item>android.car.usb.handler/android.car.usb.handler.UsbHostManagementActivity</item>
     </string-array>
+
+    <!-- TODO(b/202413464): Move GAS components to the separate RRO. -->
+    <!-- The ComponentName of Assistant VoicePlate Activity, the Activity will be placed in
+        VoicePlate TDA -->
+    <string name="config_assistantVoicePlateActivity" translatable="false">
+        com.google.android.carassistant/com.google.android.apps.gsa.binaries.auto.app.voiceplate.VoicePlateActivity
+    </string>
 </resources>
diff --git a/car_product/car_ui_portrait/rro/CarUiPortraitLauncherRRO/res/xml/overlays.xml b/car_product/car_ui_portrait/rro/CarUiPortraitLauncherRRO/res/xml/overlays.xml
index d15e291..241e6ae 100644
--- a/car_product/car_ui_portrait/rro/CarUiPortraitLauncherRRO/res/xml/overlays.xml
+++ b/car_product/car_ui_portrait/rro/CarUiPortraitLauncherRRO/res/xml/overlays.xml
@@ -62,7 +62,9 @@
 
     <item target="drawable/default_audio_background" value="@drawable/default_audio_background"/>
 
+    <item target="string/config_assistantVoicePlateActivity" value="@string/config_assistantVoicePlateActivity"/>
+
     <item target="array/config_homeCardModuleClasses" value="@array/config_homeCardModuleClasses"/>
     <item target="array/config_foregroundDAComponents" value="@array/config_foregroundDAComponents"/>
     <item target="array/config_ignoreOpeningForegroundDA" value="@array/config_ignoreOpeningForegroundDA"/>
-</overlay>
\ No newline at end of file
+</overlay>
diff --git a/car_product/car_ui_portrait/rro/CarUiPortraitSettingsRRO/res/animator/trans_fade_in.xml b/car_product/car_ui_portrait/rro/CarUiPortraitSettingsRRO/res/animator/trans_fade_in.xml
new file mode 100644
index 0000000..76c08d9
--- /dev/null
+++ b/car_product/car_ui_portrait/rro/CarUiPortraitSettingsRRO/res/animator/trans_fade_in.xml
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2021 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  -->
+
+<set xmlns:android="http://schemas.android.com/apk/res/android">
+    <objectAnimator
+        android:duration="@android:integer/config_longAnimTime"
+        android:interpolator="@android:interpolator/decelerate_quint"
+        android:propertyName="alpha"
+        android:valueFrom="0.0"
+        android:valueTo="1.0"
+        android:valueType="floatType"/>
+</set>
diff --git a/car_product/car_ui_portrait/rro/CarUiPortraitSettingsRRO/res/animator/trans_fade_out.xml b/car_product/car_ui_portrait/rro/CarUiPortraitSettingsRRO/res/animator/trans_fade_out.xml
new file mode 100644
index 0000000..482327a
--- /dev/null
+++ b/car_product/car_ui_portrait/rro/CarUiPortraitSettingsRRO/res/animator/trans_fade_out.xml
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2021 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  -->
+
+<set xmlns:android="http://schemas.android.com/apk/res/android">
+    <objectAnimator
+        android:duration="@android:integer/config_longAnimTime"
+        android:interpolator="@android:interpolator/decelerate_quint"
+        android:propertyName="alpha"
+        android:valueFrom="1.0"
+        android:valueTo="0.0"
+        android:valueType="floatType"/>
+</set>
diff --git a/car_product/car_ui_portrait/rro/CarUiPortraitSettingsRRO/res/xml/overlays.xml b/car_product/car_ui_portrait/rro/CarUiPortraitSettingsRRO/res/xml/overlays.xml
index c37acee..cc1dc2f 100644
--- a/car_product/car_ui_portrait/rro/CarUiPortraitSettingsRRO/res/xml/overlays.xml
+++ b/car_product/car_ui_portrait/rro/CarUiPortraitSettingsRRO/res/xml/overlays.xml
@@ -20,4 +20,8 @@
 
     <item target="layout/top_level_preference" value="@layout/top_level_preference"/>
 
+    <item target="animator/trans_left_in" value="@animator/trans_fade_in"/>
+    <item target="animator/trans_left_out" value="@animator/trans_fade_out"/>
+    <item target="animator/trans_right_in" value="@animator/trans_fade_in"/>
+    <item target="animator/trans_right_out" value="@animator/trans_fade_out"/>
 </overlay>
diff --git a/packages/ScriptExecutor/Android.bp b/packages/ScriptExecutor/Android.bp
index 42cb082..643fb37 100644
--- a/packages/ScriptExecutor/Android.bp
+++ b/packages/ScriptExecutor/Android.bp
@@ -16,62 +16,43 @@
     default_applicable_licenses: ["Android-Apache-2.0"],
 }
 
-cc_defaults {
-    name: "scriptexecutor_defaults",
+cc_library {
+    name: "libscriptexecutorjni",
 
     cflags: [
         "-Wno-unused-parameter",
     ],
-
-    shared_libs: [
-        "libbase",
-        "liblog",
+    header_libs: [
+        "jni_headers",
     ],
 
     static_libs: [
         "liblua",
+        "libbase_ndk",
     ],
-}
 
-cc_library {
-    name: "libscriptexecutor",
-
-    defaults: [
-        "scriptexecutor_defaults",
+    shared_libs: [
+        "liblog",
     ],
 
     srcs: [
         "src/BundleWrapper.cpp",
         "src/JniUtils.cpp",
         "src/LuaEngine.cpp",
+        "src/ScriptExecutorJni.cpp",
         "src/ScriptExecutorListener.cpp",
     ],
 
-    shared_libs: [
-        "libnativehelper",
-    ],
+    sdk_version: "current",
+
+    min_sdk_version: "30",
+
+    stl: "libc++_static",
 
     // Allow dependents to use the header files.
     export_include_dirs: ["src"],
 }
 
-cc_library {
-    name: "libscriptexecutorjni",
-
-    defaults: [
-        "scriptexecutor_defaults",
-    ],
-
-    srcs: [
-        "src/ScriptExecutorJni.cpp",
-    ],
-
-    shared_libs: [
-        "libnativehelper",
-        "libscriptexecutor",
-    ],
-}
-
 android_app {
     name: "ScriptExecutor",
 
@@ -82,8 +63,9 @@
 
     resource_dirs: ["res"],
 
-    // TODO(197006437): Make this build against sdk_version: "module_current" instead.
-    platform_apis: true,
+    sdk_version: "module_current",
+
+    min_sdk_version: "30",
 
     privileged: false,
 
@@ -92,16 +74,9 @@
         enabled: false,
     },
 
-    aidl: {
-        include_dirs: [
-            // TODO(b/198195711): Remove once we compile against SDK.
-            "frameworks/native/aidl/binder", // For PersistableBundle.aidl
-        ],
-    },
-
     jni_libs: [
         "libscriptexecutorjni",
-    ]
+    ],
 }
 
 java_test_helper_library {
@@ -112,11 +87,6 @@
         "src/**/*.java",
     ],
 
-    aidl: {
-        include_dirs: [
-            // TODO(b/198195711): Remove once we compile against SDK.
-            "frameworks/native/aidl/binder", // For PersistableBundle.aidl
-        ],
-    },
+    sdk_version: "current",
 }
 
diff --git a/packages/ScriptExecutor/src/BundleWrapper.cpp b/packages/ScriptExecutor/src/BundleWrapper.cpp
index 8957833..36c9196 100644
--- a/packages/ScriptExecutor/src/BundleWrapper.cpp
+++ b/packages/ScriptExecutor/src/BundleWrapper.cpp
@@ -16,13 +16,34 @@
 
 #include "BundleWrapper.h"
 
-#include <android-base/logging.h>
 
 namespace com {
 namespace android {
 namespace car {
 namespace scriptexecutor {
 
+using ::android::base::Error;
+using ::android::base::Result;
+
+namespace {
+
+Result<jstring> TryCreateUTFString(JNIEnv* env, const char* string) {
+    jstring utfString = env->NewStringUTF(string);
+    if (env->ExceptionCheck()) {
+        // NewStringUTF throws an exception if we run out of memory while creating a UTF string.
+        return Error()
+                << "NewStringUTF ran out of memory while converting a string provided by Lua.";
+    }
+    if (utfString == nullptr) {
+        return Error()
+                << "Failed to convert a Lua string into a modified UTF-8 string. Please verify "
+                   "that the string returned by Lua is in proper Modified UTF-8 format.";
+    }
+    return utfString;
+}
+
+}  // namespace
+
 BundleWrapper::BundleWrapper(JNIEnv* env) {
     mJNIEnv = env;
     mBundleClass = static_cast<jclass>(
@@ -41,47 +62,93 @@
     }
 }
 
-void BundleWrapper::putBoolean(const char* key, bool value) {
+Result<void> BundleWrapper::putBoolean(const char* key, bool value) {
+    auto keyStringResult = TryCreateUTFString(mJNIEnv, key);
+    if (!keyStringResult.ok()) {
+        return Error() << "Failed to create a string for key=" << key << ". "
+                       << keyStringResult.error();
+    }
+
     // TODO(b/188832769): consider caching the references.
     jmethodID putBooleanMethod =
             mJNIEnv->GetMethodID(mBundleClass, "putBoolean", "(Ljava/lang/String;Z)V");
-    mJNIEnv->CallVoidMethod(mBundle, putBooleanMethod, mJNIEnv->NewStringUTF(key),
+    mJNIEnv->CallVoidMethod(mBundle, putBooleanMethod, keyStringResult.value(),
                             static_cast<jboolean>(value));
+    return {};  // ok result
 }
 
-void BundleWrapper::putLong(const char* key, int64_t value) {
+Result<void> BundleWrapper::putLong(const char* key, int64_t value) {
+    auto keyStringResult = TryCreateUTFString(mJNIEnv, key);
+    if (!keyStringResult.ok()) {
+        return Error() << "Failed to create a string for key=" << key << ". "
+                       << keyStringResult.error();
+    }
+
     jmethodID putLongMethod =
             mJNIEnv->GetMethodID(mBundleClass, "putLong", "(Ljava/lang/String;J)V");
-    mJNIEnv->CallVoidMethod(mBundle, putLongMethod, mJNIEnv->NewStringUTF(key),
+    mJNIEnv->CallVoidMethod(mBundle, putLongMethod, keyStringResult.value(),
                             static_cast<jlong>(value));
+    return {};  // ok result
 }
 
-void BundleWrapper::putDouble(const char* key, double value) {
+Result<void> BundleWrapper::putDouble(const char* key, double value) {
+    auto keyStringResult = TryCreateUTFString(mJNIEnv, key);
+    if (!keyStringResult.ok()) {
+        return Error() << "Failed to create a string for key=" << key << ". "
+                       << keyStringResult.error();
+    }
+
     jmethodID putDoubleMethod =
             mJNIEnv->GetMethodID(mBundleClass, "putDouble", "(Ljava/lang/String;D)V");
-    mJNIEnv->CallVoidMethod(mBundle, putDoubleMethod, mJNIEnv->NewStringUTF(key),
+    mJNIEnv->CallVoidMethod(mBundle, putDoubleMethod, keyStringResult.value(),
                             static_cast<jdouble>(value));
+    return {};  // ok result
 }
 
-void BundleWrapper::putString(const char* key, const char* value) {
+Result<void> BundleWrapper::putString(const char* key, const char* value) {
     jmethodID putStringMethod = mJNIEnv->GetMethodID(mBundleClass, "putString",
                                                      "(Ljava/lang/String;Ljava/lang/String;)V");
     // TODO(b/201008922): Handle a case when NewStringUTF returns nullptr (fails
     // to create a string).
-    mJNIEnv->CallVoidMethod(mBundle, putStringMethod, mJNIEnv->NewStringUTF(key),
-                            mJNIEnv->NewStringUTF(value));
+    auto keyStringResult = TryCreateUTFString(mJNIEnv, key);
+    if (!keyStringResult.ok()) {
+        return Error() << "Failed to create a string for key=" << key << ". "
+                       << keyStringResult.error();
+    }
+    auto valueStringResult = TryCreateUTFString(mJNIEnv, value);
+    if (!valueStringResult.ok()) {
+        return Error() << "Failed to create a string for value=" << value << ". "
+                       << valueStringResult.error();
+    }
+
+    mJNIEnv->CallVoidMethod(mBundle, putStringMethod, keyStringResult.value(),
+                            valueStringResult.value());
+    return {};  // ok result
 }
 
-void BundleWrapper::putLongArray(const char* key, const std::vector<int64_t>& value) {
+Result<void> BundleWrapper::putLongArray(const char* key, const std::vector<int64_t>& value) {
+    auto keyStringResult = TryCreateUTFString(mJNIEnv, key);
+    if (!keyStringResult.ok()) {
+        return Error() << "Failed to create a string for key=" << key << ". "
+                       << keyStringResult.error();
+    }
+
     jmethodID putLongArrayMethod =
             mJNIEnv->GetMethodID(mBundleClass, "putLongArray", "(Ljava/lang/String;[J)V");
 
     jlongArray array = mJNIEnv->NewLongArray(value.size());
     mJNIEnv->SetLongArrayRegion(array, 0, value.size(), &value[0]);
-    mJNIEnv->CallVoidMethod(mBundle, putLongArrayMethod, mJNIEnv->NewStringUTF(key), array);
+    mJNIEnv->CallVoidMethod(mBundle, putLongArrayMethod, keyStringResult.value(), array);
+    return {};  // ok result
 }
 
-void BundleWrapper::putStringArray(const char* key, const std::vector<std::string>& value) {
+Result<void> BundleWrapper::putStringArray(const char* key, const std::vector<std::string>& value) {
+    auto keyStringResult = TryCreateUTFString(mJNIEnv, key);
+    if (!keyStringResult.ok()) {
+        return Error() << "Failed to create a string for key=" << key << ". "
+                       << keyStringResult.error();
+    }
+
     jmethodID putStringArrayMethod =
             mJNIEnv->GetMethodID(mBundleClass, "putStringArray",
                                  "(Ljava/lang/String;[Ljava/lang/String;)V");
@@ -91,9 +158,15 @@
     // TODO(b/201008922): Handle a case when NewStringUTF returns nullptr (fails
     // to create a string).
     for (int i = 0; i < value.size(); i++) {
-        mJNIEnv->SetObjectArrayElement(array, i, mJNIEnv->NewStringUTF(value[i].c_str()));
+        auto valueStringResult = TryCreateUTFString(mJNIEnv, value[i].c_str());
+        if (!valueStringResult.ok()) {
+            return Error() << "Failed to create a string for value=" << value[i].c_str() << ". "
+                           << valueStringResult.error();
+        }
+        mJNIEnv->SetObjectArrayElement(array, i, valueStringResult.value());
     }
-    mJNIEnv->CallVoidMethod(mBundle, putStringArrayMethod, mJNIEnv->NewStringUTF(key), array);
+    mJNIEnv->CallVoidMethod(mBundle, putStringArrayMethod, keyStringResult.value(), array);
+    return {};  // ok result
 }
 
 jobject BundleWrapper::getBundle() {
diff --git a/packages/ScriptExecutor/src/BundleWrapper.h b/packages/ScriptExecutor/src/BundleWrapper.h
index 7303bd0..a949108 100644
--- a/packages/ScriptExecutor/src/BundleWrapper.h
+++ b/packages/ScriptExecutor/src/BundleWrapper.h
@@ -19,6 +19,8 @@
 
 #include "jni.h"
 
+#include <android-base/result.h>
+
 #include <string>
 #include <vector>
 
@@ -39,12 +41,13 @@
 
     // Family of methods that puts the provided 'value' into the PersistableBundle
     // under provided 'key'.
-    void putBoolean(const char* key, bool value);
-    void putLong(const char* key, int64_t value);
-    void putDouble(const char* key, double value);
-    void putString(const char* key, const char* value);
-    void putLongArray(const char* key, const std::vector<int64_t>& value);
-    void putStringArray(const char* key, const std::vector<std::string>& value);
+    ::android::base::Result<void> putBoolean(const char* key, bool value);
+    ::android::base::Result<void> putLong(const char* key, int64_t value);
+    ::android::base::Result<void> putDouble(const char* key, double value);
+    ::android::base::Result<void> putString(const char* key, const char* value);
+    ::android::base::Result<void> putLongArray(const char* key, const std::vector<int64_t>& value);
+    ::android::base::Result<void> putStringArray(const char* key,
+                                                 const std::vector<std::string>& value);
 
     jobject getBundle();
 
diff --git a/packages/ScriptExecutor/src/JniUtils.cpp b/packages/ScriptExecutor/src/JniUtils.cpp
index 3152722..adc8d84 100644
--- a/packages/ScriptExecutor/src/JniUtils.cpp
+++ b/packages/ScriptExecutor/src/JniUtils.cpp
@@ -74,7 +74,6 @@
         } else if (env->IsInstanceOf(value, longClass)) {
             jmethodID longMethod = env->GetMethodID(longClass, "longValue", "()J");
             lua_pushinteger(luaEngine->getLuaState(), env->CallLongMethod(value, longMethod));
-
         } else if (env->IsInstanceOf(value, numberClass)) {
             // Condense other numeric types using one class. Because lua supports only
             // integer or double, and we handled integer in previous if clause.
diff --git a/packages/ScriptExecutor/src/LuaEngine.cpp b/packages/ScriptExecutor/src/LuaEngine.cpp
index fa5e0f6..c26198f 100644
--- a/packages/ScriptExecutor/src/LuaEngine.cpp
+++ b/packages/ScriptExecutor/src/LuaEngine.cpp
@@ -18,8 +18,6 @@
 
 #include "BundleWrapper.h"
 
-#include <android-base/logging.h>
-
 #include <sstream>
 #include <string>
 #include <utility>
@@ -36,13 +34,16 @@
 namespace car {
 namespace scriptexecutor {
 
+using ::android::base::Error;
+using ::android::base::Result;
+
 namespace {
 
 enum LuaNumReturnedResults {
     ZERO_RETURNED_RESULTS = 0,
 };
 
-// TODO(199415783): Revisit the topic of limits to potentially move it to standalone file.
+// TODO(b/199415783): Revisit the topic of limits to potentially move it to standalone file.
 constexpr int MAX_ARRAY_SIZE = 1000;
 
 // Helper method that goes over Lua table fields one by one and populates PersistableBundle
@@ -51,9 +52,12 @@
 //
 // Returns false if the conversion encountered unrecoverable error.
 // Otherwise, returns true for success.
+// In case of an error, there is no need to pop elements or clean the stack. When Lua calls C,
+// the stack used to pass data between Lua and C is private for each call. According to
+// https://www.lua.org/pil/26.1.html, after C function returns back to Lua, Lua
+// removes everything that is in the stack below the returned results.
 // TODO(b/200849134): Refactor this function.
-bool convertLuaTableToBundle(lua_State* lua, BundleWrapper* bundleWrapper,
-                             ScriptExecutorListener* listener) {
+Result<void> convertLuaTableToBundle(lua_State* lua, BundleWrapper* bundleWrapper) {
     // Iterate over Lua table which is expected to be at the top of Lua stack.
     // lua_next call pops the key from the top of the stack and finds the next
     // key-value pair. It returns 0 if the next pair was not found.
@@ -64,45 +68,52 @@
         // -1 index is the top of the stack.
         // remove 'value' and keep 'key' for next iteration
         // Process each key-value depending on a type and push it to Java PersistableBundle.
-        // TODO(199531928): Consider putting limits on key sizes as well.
+        // TODO(b/199531928): Consider putting limits on key sizes as well.
         const char* key = lua_tostring(lua, /* index = */ -2);
+        Result<void> bundleInsertionResult;
         if (lua_isboolean(lua, /* index = */ -1)) {
-            bundleWrapper->putBoolean(key, static_cast<bool>(lua_toboolean(lua, /* index = */ -1)));
+            bundleInsertionResult =
+                    bundleWrapper->putBoolean(key,
+                                              static_cast<bool>(
+                                                      lua_toboolean(lua, /* index = */ -1)));
         } else if (lua_isinteger(lua, /* index = */ -1)) {
-            bundleWrapper->putLong(key, static_cast<int64_t>(lua_tointeger(lua, /* index = */ -1)));
+            bundleInsertionResult =
+                    bundleWrapper->putLong(key,
+                                           static_cast<int64_t>(
+                                                   lua_tointeger(lua, /* index = */ -1)));
         } else if (lua_isnumber(lua, /* index = */ -1)) {
-            bundleWrapper->putDouble(key, static_cast<double>(lua_tonumber(lua, /* index = */ -1)));
+            bundleInsertionResult =
+                    bundleWrapper->putDouble(key,
+                                             static_cast<double>(
+                                                     lua_tonumber(lua, /* index = */ -1)));
         } else if (lua_isstring(lua, /* index = */ -1)) {
-            // TODO(199415783): We need to have a limit on how long these strings could be.
-            bundleWrapper->putString(key, lua_tostring(lua, /* index = */ -1));
+            // TODO(b/199415783): We need to have a limit on how long these strings could be.
+            bundleInsertionResult =
+                    bundleWrapper->putString(key, lua_tostring(lua, /* index = */ -1));
         } else if (lua_istable(lua, /* index =*/-1)) {
             // Lua uses tables to represent an array.
 
-            // TODO(199438375): Document to users that we expect tables to be either only indexed or
-            // keyed but not both. If the table contains consecutively indexed values starting from
-            // 1, we will treat it as an array. lua_rawlen call returns the size of the indexed
+            // TODO(b/199438375): Document to users that we expect tables to be either only indexed
+            // or keyed but not both. If the table contains consecutively indexed values starting
+            // from 1, we will treat it as an array. lua_rawlen call returns the size of the indexed
             // part. We copy this part into an array, but any keyed values in this table are
             // ignored. There is a test that documents this current behavior. If a user wants a
             // nested table to be represented by a PersistableBundle object, they must make sure
             // that the nested table does not contain indexed data, including no key=1.
             const auto kTableLength = lua_rawlen(lua, -1);
             if (kTableLength > MAX_ARRAY_SIZE) {
-                std::ostringstream out;
-                out << "Returned table " << key << " exceeds maximum allowed size of "
-                    << MAX_ARRAY_SIZE
-                    << " elements. This key-value cannot be unpacked successfully. This error "
-                       "is unrecoverable.";
-                listener->onError(ERROR_TYPE_LUA_SCRIPT_ERROR, out.str().c_str(), "");
-                return false;
+                return Error()
+                        << "Returned table " << key << " exceeds maximum allowed size of "
+                        << MAX_ARRAY_SIZE
+                        << " elements. This key-value cannot be unpacked successfully. This error "
+                           "is unrecoverable.";
             }
             if (kTableLength <= 0) {
-                std::ostringstream out;
-                out << "A value with key=" << key
-                    << " appears to be a nested table that does not represent an array of data. "
-                       "Such nested tables are not supported yet. This script error is "
-                       "unrecoverable.";
-                listener->onError(ERROR_TYPE_LUA_SCRIPT_ERROR, out.str().c_str(), "");
-                return false;
+                return Error() << "A value with key=" << key
+                               << " appears to be a nested table that does not represent an array "
+                                  "of data. "
+                                  "Such nested tables are not supported yet. This script error is "
+                                  "unrecoverable.";
             }
 
             std::vector<int64_t> longArray;
@@ -121,21 +132,20 @@
                 }
                 int currentType = lua_type(lua, /* index= */ -1);
                 if (currentType != originalLuaType) {
-                    std::ostringstream out;
-                    out << "Returned Lua arrays must have elements of the same type. Returned "
-                           "table with key="
-                        << key << " has the first element of type=" << originalLuaType
-                        << ", but the element at index=" << i + 1 << " has type=" << currentType
-                        << ". Integer type codes are defined in lua.h file. This error is "
-                           "unrecoverable.";
-                    listener->onError(ERROR_TYPE_LUA_SCRIPT_ERROR, out.str().c_str(), "");
-                    lua_pop(lua, 1);
-                    return false;
+                    return Error()
+                            << "Returned Lua arrays must have elements of the same type. Returned "
+                               "table with key="
+                            << key << " has the first element of type=" << originalLuaType
+                            << ", but the element at index=" << i + 1 << " has type=" << currentType
+                            << ". Integer type codes are defined in lua.h file. This error is "
+                               "unrecoverable.";
                 }
                 switch (currentType) {
                     case LUA_TNUMBER:
                         if (!lua_isinteger(lua, /* index = */ -1)) {
-                            LOG(WARNING) << "Floating array types are not supported yet. Skipping.";
+                            return Error() << "Returned value for key=" << key
+                                           << " contains a floating number array, which is not "
+                                              "supported yet.";
                         } else {
                             longArray.push_back(lua_tointeger(lua, /* index = */ -1));
                         }
@@ -147,31 +157,37 @@
                         stringArray.push_back(lua_tostring(lua, /* index = */ -1));
                         break;
                     default:
-                        LOG(WARNING) << "Lua array with elements of type=" << currentType
-                                     << " are not supported. Skipping.";
+                        return Error() << "Returned value for key=" << key
+                                       << " is an array with values of type="
+                                       << lua_typename(lua, lua_type(lua, /* index = */ -1))
+                                       << ", which is not supported yet.";
                 }
                 lua_pop(lua, 1);
             }
             switch (originalLuaType) {
                 case LUA_TNUMBER:
-                    bundleWrapper->putLongArray(key, longArray);
+                    bundleInsertionResult = bundleWrapper->putLongArray(key, longArray);
                     break;
                 case LUA_TSTRING:
-                    bundleWrapper->putStringArray(key, stringArray);
+                    bundleInsertionResult = bundleWrapper->putStringArray(key, stringArray);
                     break;
             }
         } else {
-            // not supported yet...
-            // TODO(199439259): Instead of logging here, log and send to user instead, and continue
-            // unpacking the rest of the table.
-            LOG(WARNING) << "key=" << key << " has a Lua type which is not supported yet. "
-                         << "The bundle object will not have this key-value pair.";
+            return Error() << "key=" << key << " has a Lua type="
+                           << lua_typename(lua, lua_type(lua, /* index = */ -1))
+                           << ", which is not supported yet.";
         }
         // Pop value from the stack, keep the key for the next iteration.
         lua_pop(lua, 1);
         // The key is at index -1, the table is at index -2 now.
+
+        // Check if insertion of the current key-value into the bundle was successful. If not,
+        // fail-fast out of this extraction routine.
+        if (!bundleInsertionResult.ok()) {
+            return bundleInsertionResult;
+        }
     }
-    return true;
+    return {};  // ok result
 }
 
 }  // namespace
@@ -212,8 +228,11 @@
         // ~20 elements and its critical function because all interaction with
         // Lua happens via the stack.
         // Starting read about Lua stack: https://www.lua.org/pil/24.2.html
-        // TODO(b/192284232): add test case to trigger this.
         lua_pop(mLuaState, 1);
+        std::ostringstream out;
+        out << "Error encountered while loading the script. A possible cause could be syntax "
+               "errors in the script.";
+        sListener->onError(ERROR_TYPE_LUA_RUNTIME_ERROR, out.str().c_str(), "");
         return status;
     }
 
@@ -224,7 +243,7 @@
     return status;
 }
 
-bool LuaEngine::pushFunction(const char* functionName) {
+int LuaEngine::pushFunction(const char* functionName) {
     // Interaction between native code and Lua happens via Lua stack.
     // In such model, a caller first pushes the name of the function
     // that needs to be called, followed by the function's input
@@ -232,8 +251,13 @@
     // More info: https://www.lua.org/pil/24.2.html
     lua_getglobal(mLuaState, functionName);
     const auto status = lua_isfunction(mLuaState, /*idx= */ -1);
-    // TODO(b/192284785): add test case for wrong function name in Lua.
-    if (status == 0) lua_pop(mLuaState, 1);
+    if (status == 0) {
+        lua_pop(mLuaState, 1);
+        std::ostringstream out;
+        out << "Wrong function name. Provided functionName=" << functionName
+            << " does not correspond to any function in the provided script";
+        sListener->onError(ERROR_TYPE_LUA_RUNTIME_ERROR, out.str().c_str(), "");
+    }
     return status;
 }
 
@@ -242,8 +266,15 @@
     // input arguments are in the Lua stack as well in proper order.
     // On how to call Lua functions: https://www.lua.org/pil/25.2.html
     // Doc on lua_pcall: https://www.lua.org/manual/5.3/manual.html#lua_pcall
-    // TODO(b/192284612): add test case for failed call.
-    return lua_pcall(mLuaState, /* nargs= */ 2, /* nresults= */ 0, /*errfunc= */ 0);
+    int status = lua_pcall(mLuaState, /* nargs= */ 2, /* nresults= */ 0, /*errfunc= */ 0);
+    if (status) {
+        lua_pop(mLuaState, 1);  // pop the error object from the stack.
+        std::ostringstream out;
+        out << "Error encountered while running the script. The returned error code=" << status
+            << ". Refer to lua.h file of Lua C API library for error code definitions.";
+        sListener->onError(ERROR_TYPE_LUA_RUNTIME_ERROR, out.str().c_str(), "");
+    }
+    return status;
 }
 
 int LuaEngine::onSuccess(lua_State* lua) {
@@ -257,11 +288,17 @@
 
     // Helper object to create and populate Java PersistableBundle object.
     BundleWrapper bundleWrapper(sListener->getCurrentJNIEnv());
-    if (convertLuaTableToBundle(lua, &bundleWrapper, sListener)) {
-        // Forward the populated Bundle object to Java callback.
-        sListener->onSuccess(bundleWrapper.getBundle());
+    const auto status = convertLuaTableToBundle(lua, &bundleWrapper);
+    if (!status.ok()) {
+        sListener->onError(ERROR_TYPE_LUA_SCRIPT_ERROR, status.error().message().c_str(), "");
+        // We explicitly must tell Lua how many results we return, which is 0 in this case.
+        // More on the topic: https://www.lua.org/manual/5.3/manual.html#lua_CFunction
+        return ZERO_RETURNED_RESULTS;
     }
 
+    // Forward the populated Bundle object to Java callback.
+    sListener->onSuccess(bundleWrapper.getBundle());
+
     // We explicitly must tell Lua how many results we return, which is 0 in this case.
     // More on the topic: https://www.lua.org/manual/5.3/manual.html#lua_CFunction
     return ZERO_RETURNED_RESULTS;
@@ -279,11 +316,17 @@
 
     // Helper object to create and populate Java PersistableBundle object.
     BundleWrapper bundleWrapper(sListener->getCurrentJNIEnv());
-    if (convertLuaTableToBundle(lua, &bundleWrapper, sListener)) {
-        // Forward the populated Bundle object to Java callback.
-        sListener->onScriptFinished(bundleWrapper.getBundle());
+    const auto status = convertLuaTableToBundle(lua, &bundleWrapper);
+    if (!status.ok()) {
+        sListener->onError(ERROR_TYPE_LUA_SCRIPT_ERROR, status.error().message().c_str(), "");
+        // We explicitly must tell Lua how many results we return, which is 0 in this case.
+        // More on the topic: https://www.lua.org/manual/5.3/manual.html#lua_CFunction
+        return ZERO_RETURNED_RESULTS;
     }
 
+    // Forward the populated Bundle object to Java callback.
+    sListener->onScriptFinished(bundleWrapper.getBundle());
+
     // We explicitly must tell Lua how many results we return, which is 0 in this case.
     // More on the topic: https://www.lua.org/manual/5.3/manual.html#lua_CFunction
     return ZERO_RETURNED_RESULTS;
diff --git a/packages/ScriptExecutor/src/LuaEngine.h b/packages/ScriptExecutor/src/LuaEngine.h
index 0774108..e5ffd0d 100644
--- a/packages/ScriptExecutor/src/LuaEngine.h
+++ b/packages/ScriptExecutor/src/LuaEngine.h
@@ -45,14 +45,16 @@
     int loadScript(const char* scriptBody);
 
     // Pushes a Lua function under provided name into the stack.
-    // Returns true if successful.
-    bool pushFunction(const char* functionName);
+    // Returns 1 if successful. Otherwise, an error is sent back to the client via the callback
+    // and 0 is returned.
+    int pushFunction(const char* functionName);
 
     // Invokes function with the inputs provided in the stack.
     // Assumes that the script body has been already loaded and successfully
     // compiled and run, and all input arguments, and the function have been
     // pushed to the stack.
-    // Returns 0 if successful. Otherwise returns non-zero Lua error code.
+    // Returns 0 if successful. Otherwise returns non-zero Lua error code
+    // and sends the error via a callback back to the client.
     int run();
 
     // Updates stored listener and destroys the previous one.
diff --git a/packages/ScriptExecutor/src/ScriptExecutorJni.cpp b/packages/ScriptExecutor/src/ScriptExecutorJni.cpp
index a5add58..cab8ece 100644
--- a/packages/ScriptExecutor/src/ScriptExecutorJni.cpp
+++ b/packages/ScriptExecutor/src/ScriptExecutorJni.cpp
@@ -19,8 +19,6 @@
 #include "ScriptExecutorListener.h"
 #include "jni.h"
 
-#include <android-base/logging.h>
-
 #include <cstdint>
 
 namespace com {
@@ -84,27 +82,23 @@
     }
 
     LuaEngine* engine = reinterpret_cast<LuaEngine*>(static_cast<intptr_t>(luaEnginePtr));
+    LuaEngine::resetListener(new ScriptExecutorListener(env, listener));
 
     // Load and parse the script
     const char* scriptStr = env->GetStringUTFChars(scriptBody, nullptr);
     auto status = engine->loadScript(scriptStr);
     env->ReleaseStringUTFChars(scriptBody, scriptStr);
     // status == 0 if the script loads successfully.
-    if (status) {
-        env->ThrowNew(env->FindClass("java/lang/IllegalArgumentException"),
-                      "Failed to load the script.");
+    if (status != 0) {
         return;
     }
-    LuaEngine::resetListener(new ScriptExecutorListener(env, listener));
 
     // Push the function name we want to invoke to Lua stack
     const char* functionNameStr = env->GetStringUTFChars(functionName, nullptr);
     status = engine->pushFunction(functionNameStr);
     env->ReleaseStringUTFChars(functionName, functionNameStr);
-    // status == 1 if the name is indeed a function.
-    if (!status) {
-        env->ThrowNew(env->FindClass("java/lang/IllegalArgumentException"),
-                      "symbol functionName does not correspond to a function.");
+    // status == 1 if the name is a valid function.
+    if (status == 0) {
         return;
     }
 
@@ -116,11 +110,7 @@
     pushBundleToLuaTable(env, engine, savedState);
 
     // Execute the function. This will block until complete or error.
-    if (engine->run()) {
-        env->ThrowNew(env->FindClass("java/lang/RuntimeException"),
-                      "Runtime error occurred while running the function.");
-        return;
-    }
+    engine->run();
 }
 
 }  // extern "C"
diff --git a/packages/ScriptExecutor/src/com/android/car/scriptexecutor/ScriptExecutor.java b/packages/ScriptExecutor/src/com/android/car/scriptexecutor/ScriptExecutor.java
index 3877693..abd4145 100644
--- a/packages/ScriptExecutor/src/com/android/car/scriptexecutor/ScriptExecutor.java
+++ b/packages/ScriptExecutor/src/com/android/car/scriptexecutor/ScriptExecutor.java
@@ -25,7 +25,6 @@
 import android.os.PersistableBundle;
 import android.os.RemoteException;
 import android.util.Log;
-import android.util.Slog;
 
 import com.android.car.telemetry.scriptexecutorinterface.IScriptExecutor;
 import com.android.car.telemetry.scriptexecutorinterface.IScriptExecutorListener;
@@ -77,7 +76,7 @@
                         if (Log.isLoggable(TAG, Log.ERROR)) {
                             // At least log "message" here, in case it was never sent back via
                             // the callback.
-                            Slog.e(TAG, "failed while calling listener with exception ", e);
+                            Log.e(TAG, "failed while calling listener with exception ", e);
                         }
                     }
                     return;
diff --git a/packages/ScriptExecutor/tests/unit/Android.bp b/packages/ScriptExecutor/tests/unit/Android.bp
index fbbe750..80ba55f 100644
--- a/packages/ScriptExecutor/tests/unit/Android.bp
+++ b/packages/ScriptExecutor/tests/unit/Android.bp
@@ -45,19 +45,26 @@
     ],
 }
 
-cc_library_shared {
+cc_library {
     name: "libscriptexecutorjniutils-test",
 
-    defaults: [
-        "scriptexecutor_defaults",
+    cflags: [
+        "-Wno-unused-parameter",
     ],
 
     srcs: [
         "src/com/android/car/scriptexecutor/JniUtilsTestHelper.cpp",
     ],
 
+    stl: "libc++_static",
+
     shared_libs: [
+        "libbase",
         "libnativehelper",
-        "libscriptexecutor",
+    ],
+
+    static_libs: [
+        "libscriptexecutorjni",
+        "liblua",
     ],
 }
diff --git a/packages/ScriptExecutor/tests/unit/src/com/android/car/scriptexecutor/ScriptExecutorTest.java b/packages/ScriptExecutor/tests/unit/src/com/android/car/scriptexecutor/ScriptExecutorTest.java
index a167b0c..5decaa3 100644
--- a/packages/ScriptExecutor/tests/unit/src/com/android/car/scriptexecutor/ScriptExecutorTest.java
+++ b/packages/ScriptExecutor/tests/unit/src/com/android/car/scriptexecutor/ScriptExecutorTest.java
@@ -150,7 +150,6 @@
                         + "    on_success(result)\n"
                         + "end\n";
 
-
         runScriptAndWaitForResponse(returnResultScript, "hello", mPublishedData, mSavedState);
 
         // Expect to get back a bundle with a single string key: string value pair:
@@ -168,7 +167,6 @@
                         + "    on_success(result)\n"
                         + "end\n";
 
-
         runScriptAndWaitForResponse(script, "knows", mPublishedData, mSavedState);
 
         // Expect to get back a bundle with 4 keys, each corresponding to a distinct supported type.
@@ -181,7 +179,7 @@
     }
 
     @Test
-    public void invokeScript_skipsUnsupportedTypes() throws RemoteException {
+    public void invokeScript_skipsUnsupportedNestedTables() throws RemoteException {
         String script =
                 "function nested(data, state)\n"
                         + "    result = {string=\"hello\", boolean=true, integer=1, number=1.1}\n"
@@ -189,7 +187,6 @@
                         + "    on_success(result)\n"
                         + "end\n";
 
-
         runScriptAndWaitForResponse(script, "nested", mPublishedData, mSavedState);
 
         // Verify that expected error is received.
@@ -207,7 +204,6 @@
                         + "    on_success(result)\n"
                         + "end\n";
 
-
         runScriptAndWaitForResponse(script, "empty", mPublishedData, mSavedState);
 
         // If a script returns empty table as the result, we get an empty bundle.
@@ -227,7 +223,6 @@
         PersistableBundle previousState = new PersistableBundle();
         previousState.putInt("x", 1);
 
-
         runScriptAndWaitForResponse(script, "update", mPublishedData, previousState);
 
         // Verify that y = 2, because y = x + 1 and x = 1.
@@ -255,7 +250,6 @@
         previousState.putBoolean("boolean", false);
         previousState.putString("string", "ABRA");
 
-
         runScriptAndWaitForResponse(script, "update_all", mPublishedData, previousState);
 
         // Verify that keys are preserved but the values are modified as expected.
@@ -289,7 +283,6 @@
         previousState.putLongArray("long_array", long_array);
         previousState.putStringArray("string_array", string_array);
 
-
         runScriptAndWaitForResponse(script, "arrays", mPublishedData, previousState);
 
         // Verify that keys are preserved but the values are modified as expected.
@@ -321,7 +314,6 @@
         previousState.putLongArray("long_array", long_array);
         long[] expected_array = new long[]{1, 100, 3};
 
-
         runScriptAndWaitForResponse(script, "modify_array", mPublishedData, previousState);
 
         // Verify that keys are preserved but the values are modified as expected.
@@ -551,7 +543,6 @@
         previousState.putBoolean("boolean", false);
         previousState.putString("string", "ABRA");
 
-
         runScriptAndWaitForResponse(script, "finalize_all", mPublishedData, previousState);
 
         // Verify that keys are preserved but the values are modified as expected.
@@ -571,7 +562,6 @@
                         + "    on_script_finished(result)\n"
                         + "end\n";
 
-
         runScriptAndWaitForResponse(script, "empty_final_result", mPublishedData, mSavedState);
 
         // If a script returns empty table as the final result, we get an empty bundle.
@@ -589,7 +579,6 @@
                         + "    on_script_finished(result, extra)\n"
                         + "end\n";
 
-
         runScriptAndWaitForResponse(script, "wrong_number_of_outputs_in_on_script_finished",
                 mPublishedData, mSavedState);
 
@@ -610,7 +599,6 @@
                         + "    on_success(result, extra)\n"
                         + "end\n";
 
-
         runScriptAndWaitForResponse(script, "wrong_number_of_outputs_in_on_success",
                 mPublishedData, mSavedState);
 
@@ -629,7 +617,6 @@
                         + "    on_success(result)\n"
                         + "end\n";
 
-
         runScriptAndWaitForResponse(script, "wrong_type_in_on_success",
                 mPublishedData, mSavedState);
 
@@ -649,7 +636,6 @@
                         + "    on_success(result)\n"
                         + "end\n";
 
-
         runScriptAndWaitForResponse(script, "wrong_type_in_on_script_finished",
                 mPublishedData, mSavedState);
 
@@ -729,7 +715,7 @@
 
         runScriptAndWaitForResponse(script, "data_and_state", publishedData, previousState);
 
-        // If a script returns empty table as the final result, we get an empty bundle.
+        // Lua script combines both input published data and previous state into a single result.
         assertThat(mFakeScriptExecutorListener.mFinalResult).isNotNull();
         assertThat(mFakeScriptExecutorListener.mFinalResult.size()).isEqualTo(1);
         assertThat(mFakeScriptExecutorListener.mFinalResult.getString("answer")).isEqualTo(
@@ -767,5 +753,138 @@
         assertThat(mFakeScriptExecutorListener.mFinalResult.getLong("int")).isEqualTo(100);
         assertThat(mFakeScriptExecutorListener.mFinalResult.getLong("long")).isEqualTo(200);
     }
+
+    @Test
+    public void invokeScript_nonUTFCharactersDoNotCauseErrors() throws RemoteException {
+        // Tries to create an output string value that does not conform to Modified UTF-8.
+        // JNI gracefully handles it by parsing on the string as is.
+        String script =
+                "function non_utf_key_string(data, state)\n"
+                        + "    result = {answer = \"i\0np\200\200ut\"}\n"
+                        + "    on_script_finished(result)\n"
+                        + "end\n";
+
+        runScriptAndWaitForResponse(script, "non_utf_key_string", new PersistableBundle(),
+                new PersistableBundle());
+
+        // The output will still have all characters, including those that do not conform to
+        // Modified UTF-8.
+        assertThat(mFakeScriptExecutorListener.mFinalResult).isNotNull();
+        assertThat(mFakeScriptExecutorListener.mFinalResult.size()).isEqualTo(1);
+        assertThat(mFakeScriptExecutorListener.mFinalResult.getString("answer")).isEqualTo(
+                "i\0np\200\200ut");
+    }
+
+    @Test
+    public void invokeScript_wrongFunctionNameProvided() throws RemoteException {
+        // Verifies that not specifying function name correctly is handled through error callback.
+        String script =
+                "function correct_function(data, state)\n"
+                        + "end\n";
+
+        runScriptAndWaitForError(script, "wrong_function");
+
+        // Verify that the expected error is received.
+        assertThat(mFakeScriptExecutorListener.mErrorType).isEqualTo(
+                IScriptExecutorListener.ERROR_TYPE_LUA_RUNTIME_ERROR);
+        assertThat(mFakeScriptExecutorListener.mMessage).contains(
+                "Wrong function name");
+    }
+
+    @Test
+    public void invokeScript_runtimeErrorDueToSyntax() throws RemoteException {
+        // Verifies that syntax errors during script loading are handled gracefully.
+        String script =
+                "function wrong_syntax(data, state)\n"
+                        + "    x == 1\n"
+                        + "end\n";
+
+        runScriptAndWaitForError(script, "wrong_syntax");
+
+        // Verify that the expected error is received.
+        assertThat(mFakeScriptExecutorListener.mErrorType).isEqualTo(
+                IScriptExecutorListener.ERROR_TYPE_LUA_RUNTIME_ERROR);
+        assertThat(mFakeScriptExecutorListener.mMessage).contains(
+                "Error encountered while loading the script");
+    }
+
+    @Test
+    public void invokeScript_runtimeErrorDueToUndefinedMethod() throws RemoteException {
+        // Verifies that runtime errors encountered during Lua script execution trigger an error
+        // returned via a callback.
+        String script =
+                "function runtime_error(data, state)\n"
+                        + "    on_problem(data, state)\n"
+                        + "end\n";
+
+        runScriptAndWaitForError(script, "runtime_error");
+
+        // Verify that the expected error is received.
+        assertThat(mFakeScriptExecutorListener.mErrorType).isEqualTo(
+                IScriptExecutorListener.ERROR_TYPE_LUA_RUNTIME_ERROR);
+        assertThat(mFakeScriptExecutorListener.mMessage).contains(
+                "Error encountered while running the script");
+    }
+
+    @Test
+    public void invokeScript_returnedValuesOfUnsupportedTypesReturnError() throws RemoteException {
+        // Verifies that if we try to return a value of unsupported type, we get an error instead.
+        // In this case, the unsupported type is LUA_TFUNCTION type.
+        String script =
+                "function function_type(data, state)\n"
+                        + "    result = {fn = function_type}\n"
+                        + "    on_success(result)\n"
+                        + "end\n";
+
+        runScriptAndWaitForResponse(script, "function_type", mPublishedData, mSavedState);
+
+        // Verify that the expected error is received.
+        assertThat(mFakeScriptExecutorListener.mErrorType).isEqualTo(
+                IScriptExecutorListener.ERROR_TYPE_LUA_SCRIPT_ERROR);
+        assertThat(mFakeScriptExecutorListener.mMessage).contains(
+                "has a Lua type=function, which is not supported yet");
+    }
+
+    @Test
+    public void invokeScript_returnedFloatingArraysNotSupported() throws RemoteException {
+        // Verifies that we do not support return values that contain floating number arrays.
+        String script =
+                "function floating_point_arrays(data, state)\n"
+                        + "    array = {}\n"
+                        + "    array[0] = 1.1\n"
+                        + "    array[1] = 1.2\n"
+                        + "    result = {data = array}\n"
+                        + "    on_success(result)\n"
+                        + "end\n";
+
+        runScriptAndWaitForResponse(script, "floating_point_arrays", mPublishedData, mSavedState);
+
+        // Verify that the expected error is received.
+        assertThat(mFakeScriptExecutorListener.mErrorType).isEqualTo(
+                IScriptExecutorListener.ERROR_TYPE_LUA_SCRIPT_ERROR);
+        assertThat(mFakeScriptExecutorListener.mMessage).contains(
+                "a floating number array, which is not supported yet");
+    }
+
+    @Test
+    public void invokeScript_returnedBooleanArraysNotSupported() throws RemoteException {
+        // Verifies that we do not yet support return values that contain boolean arrays.
+        String script =
+                "function array_of_booleans(data, state)\n"
+                        + "    array = {}\n"
+                        + "    array[0] = false\n"
+                        + "    array[1] = true\n"
+                        + "    result = {data = array}\n"
+                        + "    on_success(result)\n"
+                        + "end\n";
+
+        runScriptAndWaitForResponse(script, "array_of_booleans", mPublishedData, mSavedState);
+
+        // Verify that the expected error is received.
+        assertThat(mFakeScriptExecutorListener.mErrorType).isEqualTo(
+                IScriptExecutorListener.ERROR_TYPE_LUA_SCRIPT_ERROR);
+        assertThat(mFakeScriptExecutorListener.mMessage).contains(
+                "is an array with values of type=boolean, which is not supported yet");
+    }
 }
 
diff --git a/service/res/values-af/strings.xml b/service/res/values-af/strings.xml
index ad5dfd6..22c404c 100644
--- a/service/res/values-af/strings.xml
+++ b/service/res/values-af/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Beheer motorkragbeleid."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"lewer template"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Lewer template."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"beheer die oopmaak van programme"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Beheer die oopmaak van programme."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"My Toestel"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Gas"</string>
     <string name="importance_default" msgid="8587741629268312938">"Verstekbelang"</string>
diff --git a/service/res/values-am/strings.xml b/service/res/values-am/strings.xml
index 9e0f772..65b84a5 100644
--- a/service/res/values-am/strings.xml
+++ b/service/res/values-am/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"የመኪና ኃይል መመሪያን ተቆጣጠር።"</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"የቅንብር ደንቦችን ምስል ሥራ።"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"የቅንብር ደንቦችን ምስል ሥራ።"</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"መተግበሪያዎችን ማስጀመር መቆጣጠር"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"መተግበሪያዎችን ማስጀመር መቆጣጠር።"</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"የእኔ መሣሪያ"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"እንግዳ"</string>
     <string name="importance_default" msgid="8587741629268312938">"ነባሪ አስፈላጊነት"</string>
diff --git a/service/res/values-as/strings.xml b/service/res/values-as/strings.xml
index e4c62ea..ca68c26 100644
--- a/service/res/values-as/strings.xml
+++ b/service/res/values-as/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"গাড়ীৰ পাৱাৰ পলিচী নিয়ন্ত্ৰণ কৰে।"</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"টেমপ্লে’ট প্ৰদান কৰক"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"টেমপ্লে’ট প্ৰদান কৰক।"</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"এপ্লিকেশ্বন লঞ্চ হোৱাটো নিয়ন্ত্ৰণ কৰে"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"এপ্লিকেশ্বন লঞ্চ হোৱাটো নিয়ন্ত্ৰণ কৰে।"</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"মোৰ ডিভাইচ"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"অতিথি"</string>
     <string name="importance_default" msgid="8587741629268312938">"ডিফ’ল্ট গুৰুত্ব"</string>
diff --git a/service/res/values-az/strings.xml b/service/res/values-az/strings.xml
index c6064e7..1ce1069 100644
--- a/service/res/values-az/strings.xml
+++ b/service/res/values-az/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Avtomobilin enerji siyasətini idarə edə bilir."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"şablonları vizualizasiya edin"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Şablonları vizualizasiya edin."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"tətbiqlərin başladılmasına nəzarət"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Tətbiqlərin başladılmasına nəzarət."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Cihazım"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Qonaq"</string>
     <string name="importance_default" msgid="8587741629268312938">"Defolt önəm"</string>
diff --git a/service/res/values-b+sr+Latn/strings.xml b/service/res/values-b+sr+Latn/strings.xml
index 20e1f5c..143525b 100644
--- a/service/res/values-b+sr+Latn/strings.xml
+++ b/service/res/values-b+sr+Latn/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Kontrola smernica za napajanje automobila."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"prikazivanje šablona"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Prikazivanje šablona."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"kontrola pokretanja aplikacija"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Kontroliše pokretanje aplikacija."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Moj uređaj"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Gost"</string>
     <string name="importance_default" msgid="8587741629268312938">"Podrazumevana važnost"</string>
diff --git a/service/res/values-be/strings.xml b/service/res/values-be/strings.xml
index 79acbee..fd2a287 100644
--- a/service/res/values-be/strings.xml
+++ b/service/res/values-be/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Кіраваць палітыкай сілкавання аўтамабіля."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"візуалізацыя шаблонаў"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Візуалізацыя шаблонаў."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"кіраванне запускам праграм"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Кіраванне запускам праграм."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Мая прылада"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Госць"</string>
     <string name="importance_default" msgid="8587741629268312938">"Стандартная важнасць"</string>
diff --git a/service/res/values-bg/strings.xml b/service/res/values-bg/strings.xml
index 826b2e6..185e9a7 100644
--- a/service/res/values-bg/strings.xml
+++ b/service/res/values-bg/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Управление на правилата за захранването на автомобила."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"рендериране на шаблони"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Рендериране на шаблони."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"управление на приложенията, които се стартират"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Управление на приложенията, които се стартират."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Моето устройство"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Гост"</string>
     <string name="importance_default" msgid="8587741629268312938">"Важност по подразбиране"</string>
diff --git a/service/res/values-bn/strings.xml b/service/res/values-bn/strings.xml
index 4d9dfc5..deb0dbc 100644
--- a/service/res/values-bn/strings.xml
+++ b/service/res/values-bn/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"গাড়ির পাওয়ার নীতি নিয়ন্ত্রণ করুন।"</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"টেম্পলেট রেন্ডার করুন"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"টেম্পলেট রেন্ডার করুন।"</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"অ্যাপ্লিকেশন চালু করা প্রক্রিয়া নিয়ন্ত্রণ করুন"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"অ্যাপ্লিকেশন চালু করা প্রক্রিয়া নিয়ন্ত্রণ করুন।"</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"আমার ডিভাইস"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"অতিথি"</string>
     <string name="importance_default" msgid="8587741629268312938">"ডিফল্ট গুরুত্ব"</string>
diff --git a/service/res/values-bs/strings.xml b/service/res/values-bs/strings.xml
index bcd8028..c5a7c4b 100644
--- a/service/res/values-bs/strings.xml
+++ b/service/res/values-bs/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Upravljajte pravilima uključivanja/isključivanja komponenti automobila."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"iscrtavanje šablona"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Iscrtavanje šablona."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"upravljanje pokretanjem aplikacija"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Upravljanje pokretanjem aplikacija."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Moj uređaj"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Gost"</string>
     <string name="importance_default" msgid="8587741629268312938">"Zadana važnost"</string>
diff --git a/service/res/values-ca/strings.xml b/service/res/values-ca/strings.xml
index 10564d7..333279c 100644
--- a/service/res/values-ca/strings.xml
+++ b/service/res/values-ca/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Controla la política d\'energia del cotxe."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"renderitzar plantilles"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Renderitzar plantilles."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"controla l\'inici de les aplicacions"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Controla l\'inici de les aplicacions."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"El meu dispositiu"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Convidat"</string>
     <string name="importance_default" msgid="8587741629268312938">"Importància predeterminada"</string>
diff --git a/service/res/values-cs/strings.xml b/service/res/values-cs/strings.xml
index ea872c3..c2d1537 100644
--- a/service/res/values-cs/strings.xml
+++ b/service/res/values-cs/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Ovládání zásad pro napájení komponentů auta."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"vykreslování šablon"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Vykreslování šablon."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"ovládání spouštěných aplikací"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Ovládání spouštěných aplikací."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Moje zařízení"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Host"</string>
     <string name="importance_default" msgid="8587741629268312938">"Výchozí důležitost"</string>
diff --git a/service/res/values-da/strings.xml b/service/res/values-da/strings.xml
index 3e87aa8..1196664 100644
--- a/service/res/values-da/strings.xml
+++ b/service/res/values-da/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Styr bilens politik for aktivering af komponenter."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"gengive skabeloner"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Gengive skabeloner."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"styre startapps"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Styre startapps."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Min enhed"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Gæst"</string>
     <string name="importance_default" msgid="8587741629268312938">"Standardvigtighed"</string>
diff --git a/service/res/values-de/strings.xml b/service/res/values-de/strings.xml
index 9746544..3c76d9e 100644
--- a/service/res/values-de/strings.xml
+++ b/service/res/values-de/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Richtlinie zur Stromversorgung von Komponenten im Auto steuern."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"Vorlagen werden gerendert"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Vorlagen werden gerendert."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"Der Start von Anwendungen wird gesteuert"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Der Start von Anwendungen wird gesteuert."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Mein Gerät"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Gast"</string>
     <string name="importance_default" msgid="8587741629268312938">"Wichtigkeit: Standard"</string>
diff --git a/service/res/values-el/strings.xml b/service/res/values-el/strings.xml
index e7c562a..bf3be05 100644
--- a/service/res/values-el/strings.xml
+++ b/service/res/values-el/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Έλεγχος πολιτικής ισχύος αυτοκινήτου."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"απόδοση προτύπων"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Να αποδίδει πρότυπα."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"έλεγχος εφαρμογών εκκίνησης"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Έλεγχος εφαρμογών εκκίνησης."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Η συσκευή μου"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Επισκέπτης"</string>
     <string name="importance_default" msgid="8587741629268312938">"Προεπιλεγμένη βαρύτητα"</string>
diff --git a/service/res/values-es-rUS/strings.xml b/service/res/values-es-rUS/strings.xml
index 364b2d8..75a3f27 100644
--- a/service/res/values-es-rUS/strings.xml
+++ b/service/res/values-es-rUS/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Controla la política de activación de componentes del vehículo."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"renderizar plantillas"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Renderizar plantillas"</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"controla el inicio de las aplicaciones"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Controla el inicio de las aplicaciones."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Mi dispositivo"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Invitado"</string>
     <string name="importance_default" msgid="8587741629268312938">"Importancia de config. predeterminada"</string>
diff --git a/service/res/values-es/strings.xml b/service/res/values-es/strings.xml
index 49ab196..43db6e3 100644
--- a/service/res/values-es/strings.xml
+++ b/service/res/values-es/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Controlar política de energía del coche."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"renderizar plantillas"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Renderizar plantillas."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"controla las aplicaciones abiertas"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Controla las aplicaciones abiertas."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Mi dispositivo"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Invitado"</string>
     <string name="importance_default" msgid="8587741629268312938">"Importancia predeterminada"</string>
diff --git a/service/res/values-et/strings.xml b/service/res/values-et/strings.xml
index b5b26ad..d8b4461 100644
--- a/service/res/values-et/strings.xml
+++ b/service/res/values-et/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Auto toitereeglite haldamine."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"mallide renderdamine"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Mallide renderdamine."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"rakenduste käivitamise juhtimine"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Rakenduste käivitamise juhtimine."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Minu seade"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Külaline"</string>
     <string name="importance_default" msgid="8587741629268312938">"Vaiketähtsus"</string>
diff --git a/service/res/values-eu/strings.xml b/service/res/values-eu/strings.xml
index c6f8b1e..59319f6 100644
--- a/service/res/values-eu/strings.xml
+++ b/service/res/values-eu/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Kontrolatu autoaren osagaiak aktibatzeko gidalerroak."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"errendatu txantiloiak"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Errendatu txantiloiak."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"kontrolatu abiarazteko aplikazioak"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Kontrolatu abiarazteko aplikazioak."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Nire gailua"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Gonbidatua"</string>
     <string name="importance_default" msgid="8587741629268312938">"Garrantzi lehenetsia"</string>
diff --git a/service/res/values-fa/strings.xml b/service/res/values-fa/strings.xml
index 886ca2a..7554bf8 100644
--- a/service/res/values-fa/strings.xml
+++ b/service/res/values-fa/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"کنترل خط‌مشی روشن/خاموش شدن مؤلفه‌های خودرو."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"پرداز زدن الگوها"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"پرداز زدن الگوها."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"کنترل راه‌اندازی برنامه‌ها"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"کنترل راه‌اندازی برنامه‌ها."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"دستگاه من"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"مهمان"</string>
     <string name="importance_default" msgid="8587741629268312938">"اهمیت پیش‌فرض"</string>
diff --git a/service/res/values-fi/strings.xml b/service/res/values-fi/strings.xml
index 8790d6a..2721fd5 100644
--- a/service/res/values-fi/strings.xml
+++ b/service/res/values-fi/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Ohjaa auton virtakäytäntöä"</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"renderöidä malleja"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Renderöi mallit."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"hallita sovellusten käynnistymistä"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"hallita sovellusten käynnistymistä."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Oma laite"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Vieras"</string>
     <string name="importance_default" msgid="8587741629268312938">"Oletustärkeys"</string>
diff --git a/service/res/values-fr-rCA/strings.xml b/service/res/values-fr-rCA/strings.xml
index b07851a..a7f7ef2 100644
--- a/service/res/values-fr-rCA/strings.xml
+++ b/service/res/values-fr-rCA/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Politique sur la gestion de l\'alimentation dans la voiture"</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"render effectuer un rendu des modèles"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Effectuer un rendu des modèles."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"contrôler le lancement d\'applications"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Contrôler le lancement d\'applications."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Mon appareil"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Invité"</string>
     <string name="importance_default" msgid="8587741629268312938">"Importance par défaut"</string>
diff --git a/service/res/values-fr/strings.xml b/service/res/values-fr/strings.xml
index 3ec11ec..db33d50 100644
--- a/service/res/values-fr/strings.xml
+++ b/service/res/values-fr/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Contrôlez la règle d\'activation pour la voiture."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"afficher les modèles"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Afficher les modèles."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"contrôler le lancement d\'applications."</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Contrôler le lancement d\'applications."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Mon appareil"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Invité"</string>
     <string name="importance_default" msgid="8587741629268312938">"Importance par défaut"</string>
diff --git a/service/res/values-gl/strings.xml b/service/res/values-gl/strings.xml
index 61dd97e..89fdb60 100644
--- a/service/res/values-gl/strings.xml
+++ b/service/res/values-gl/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Controlar a política de enerxía do coche."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"xerar modelos"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Xerar modelos."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"controlar o inicio de aplicacións"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Controlar o inicio de aplicacións."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Dispositivo"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Convidado"</string>
     <string name="importance_default" msgid="8587741629268312938">"Importancia predeterminada"</string>
diff --git a/service/res/values-gu/strings.xml b/service/res/values-gu/strings.xml
index ed1ea57..1542a42 100644
--- a/service/res/values-gu/strings.xml
+++ b/service/res/values-gu/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"કારની સુવિધાઓ ચાલુ/બંધ રહેવા વિશેની નીતિને નિયંત્રિત કરો."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"નમૂના જનરેટ કરો"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"નમૂના જનરેટ કરો."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"લૉન્ચિંગ ઍપ્લિકેશનો નિયંત્રિત કરો"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"લૉન્ચિંગ ઍપ્લિકેશનો નિયંત્રિત કરો."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"મારું ડિવાઇસ"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"અતિથિ"</string>
     <string name="importance_default" msgid="8587741629268312938">"ડિફૉલ્ટ મહત્ત્વ"</string>
diff --git a/service/res/values-hi/strings.xml b/service/res/values-hi/strings.xml
index acb03b0..28d6dcd 100644
--- a/service/res/values-hi/strings.xml
+++ b/service/res/values-hi/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"कार पावर नीति कंट्रोल करें."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"टेंप्लेट बनाएं"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"टेंप्लेट बनाएं."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"लॉन्च किए जाने वाले ऐप्लिकेशन कंट्रोल करता है"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"लॉन्च किए जाने वाले ऐप्लिकेशन कंट्रोल करता है."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"मेरा डिवाइस"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"मेहमान"</string>
     <string name="importance_default" msgid="8587741629268312938">"डिफ़ॉल्ट अहमियत"</string>
diff --git a/service/res/values-hr/strings.xml b/service/res/values-hr/strings.xml
index 27ed86f..a640db0 100644
--- a/service/res/values-hr/strings.xml
+++ b/service/res/values-hr/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Upravljanje pravilom napajanja automobila."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"generirati predloške"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Generirati predloške."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"upravljajte pokretanjem aplikacija"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Upravljajte pokretanjem aplikacija."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Moj uređaj"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Gost"</string>
     <string name="importance_default" msgid="8587741629268312938">"Zadana važnost"</string>
diff --git a/service/res/values-hu/strings.xml b/service/res/values-hu/strings.xml
index b757bf4..8f06ed1 100644
--- a/service/res/values-hu/strings.xml
+++ b/service/res/values-hu/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Vezérelheti az autó energiaellátási házirendjét."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"sablonok renderelése"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Sablonok renderelése."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"alkalmazásindítás vezérlése"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Alkalmazásindítás vezérlése."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Saját eszköz"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Vendég"</string>
     <string name="importance_default" msgid="8587741629268312938">"Alapértelmezett fontosságú"</string>
diff --git a/service/res/values-hy/strings.xml b/service/res/values-hy/strings.xml
index 37714ba..cf0c83f 100644
--- a/service/res/values-hy/strings.xml
+++ b/service/res/values-hy/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Կառավարել ավտոմեքենայի հզորության քաղաքականությունը։"</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"արտապատկերել ձևանմուշները"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Ձևանմուշների արտապատկերում։"</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"վերահսկել հավելվածների գործարկումը"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Վերահսկել հավելվածների գործարկումը"</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Իմ սարքը"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Հյուր"</string>
     <string name="importance_default" msgid="8587741629268312938">"Կարևորություն (կանխադրված)"</string>
diff --git a/service/res/values-in/strings.xml b/service/res/values-in/strings.xml
index 8fe082e..90679b6 100644
--- a/service/res/values-in/strings.xml
+++ b/service/res/values-in/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Kontrol kebijakan daya mobil."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"merender template"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Merender template."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"mengontrol aplikasi yang diluncurkan"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Kontrol aplikasi yang diluncurkan."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Perangkat Saya"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Tamu"</string>
     <string name="importance_default" msgid="8587741629268312938">"Tingkat kepentingan: default"</string>
diff --git a/service/res/values-is/strings.xml b/service/res/values-is/strings.xml
index 398b853..aa3a48c 100644
--- a/service/res/values-is/strings.xml
+++ b/service/res/values-is/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Stjórna ræsistýringum bíls."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"teikna sniðmát"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Teikna sniðmát."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"stjórna ræsingu forrita"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Stjórna ræsingu forrita."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Tækið mitt"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Gestur"</string>
     <string name="importance_default" msgid="8587741629268312938">"Sjálfgefið mikilvægi"</string>
diff --git a/service/res/values-it/strings.xml b/service/res/values-it/strings.xml
index c526950..765fcfe 100644
--- a/service/res/values-it/strings.xml
+++ b/service/res/values-it/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Controlla i criteri di alimentazione dell\'auto."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"Visualizzazione di modelli"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Consente di visualizzare i modelli."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"controllo avvio delle applicazioni"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Controllo avvio delle applicazioni."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Mio dispositivo"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Ospite"</string>
     <string name="importance_default" msgid="8587741629268312938">"Importanza predefinita"</string>
diff --git a/service/res/values-iw/strings.xml b/service/res/values-iw/strings.xml
index 60fcfae..47b51e3 100644
--- a/service/res/values-iw/strings.xml
+++ b/service/res/values-iw/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"שליטה במדיניות הזנת המתח של הרכב."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"עיבוד תבניות"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"עיבוד תבניות."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"שליטה בהפעלת אפליקציות"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"יש שליטה בהפעלת אפליקציות."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"המכשיר שלי"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"אורח"</string>
     <string name="importance_default" msgid="8587741629268312938">"חשיבות ברירת מחדל"</string>
diff --git a/service/res/values-ja/strings.xml b/service/res/values-ja/strings.xml
index c8f5cca..63a86b7 100644
--- a/service/res/values-ja/strings.xml
+++ b/service/res/values-ja/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"車の電源ポリシーの制御。"</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"テンプレートの表示"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"テンプレートの表示。"</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"起動アプリの管理"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"起動アプリの管理。"</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"自分のデバイス"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"ゲスト"</string>
     <string name="importance_default" msgid="8587741629268312938">"重要度: デフォルト"</string>
diff --git a/service/res/values-ka/strings.xml b/service/res/values-ka/strings.xml
index 5307ac1..e1b0832 100644
--- a/service/res/values-ka/strings.xml
+++ b/service/res/values-ka/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"აკონტროლებს მანქანაში კომპონენტების ჩართვის წესებს."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"შაბლონების ჩვენება"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"შაბლონების ჩვენება."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"აპლიკაციების გაშვების კონტროლი"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"აპლიკაციების გაშვების კონტროლი."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"ჩემი მოწყობილობა"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"სტუმარი"</string>
     <string name="importance_default" msgid="8587741629268312938">"ნაგულისხმევი მნიშვნელოვნება"</string>
diff --git a/service/res/values-kk/strings.xml b/service/res/values-kk/strings.xml
index e859148..b80ca10 100644
--- a/service/res/values-kk/strings.xml
+++ b/service/res/values-kk/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Көлік қуаты туралы саясатты басқару."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"рендеринг үлгілері"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Рендеринг үлгілері"</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"қолданбалардың іске қосылуын басқару"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Қолданбалардың іске қосылуын басқара аласыз."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Құрылғым"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Қонақ"</string>
     <string name="importance_default" msgid="8587741629268312938">"Әдепкі маңыздылық"</string>
diff --git a/service/res/values-km/strings.xml b/service/res/values-km/strings.xml
index 3d96082..fef239b 100644
--- a/service/res/values-km/strings.xml
+++ b/service/res/values-km/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"គ្រប់គ្រង​គោលការណ៍​ថាមពល​រថយន្ត។"</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"បំប្លែង​ទម្រង់គំរូ"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"បំប្លែង​ទម្រង់គំរូ។"</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"គ្រប់គ្រង​ការចាប់ផ្ដើម​កម្មវិធី"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"គ្រប់គ្រង​ការចាប់ផ្ដើម​កម្មវិធី។"</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"ឧបករណ៍របស់ខ្ញុំ"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"ភ្ញៀវ"</string>
     <string name="importance_default" msgid="8587741629268312938">"កម្រិតសំខាន់​តាមលំនាំដើម"</string>
diff --git a/service/res/values-kn/strings.xml b/service/res/values-kn/strings.xml
index f6f498a..7f854b4 100644
--- a/service/res/values-kn/strings.xml
+++ b/service/res/values-kn/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"ಕಾರಿನ ಪವರ್ ನೀತಿಯನ್ನು ನಿಯಂತ್ರಿಸಿ."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"ಟೆಂಪ್ಲೇಟ್‌ಗಳನ್ನು ರೆಂಡರ್ ಮಾಡಿ"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"ಟೆಂಪ್ಲೇಟ್‌ಗಳನ್ನು ರೆಂಡರ್ ಮಾಡಿ."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"ಪ್ರಾರಂಭಿಸುವ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿಯಂತ್ರಿಸಿ"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"ಪ್ರಾರಂಭಿಸುವ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿಯಂತ್ರಿಸಿ."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"ನನ್ನ ಸಾಧನ"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"ಅತಿಥಿ"</string>
     <string name="importance_default" msgid="8587741629268312938">"ಮಹತ್ವವಾದುದು: ಡೀಫಾಲ್ಟ್"</string>
diff --git a/service/res/values-ko/strings.xml b/service/res/values-ko/strings.xml
index 00b0db5..f0c546e 100644
--- a/service/res/values-ko/strings.xml
+++ b/service/res/values-ko/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"차량 전원 정책을 관리합니다."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"템플릿 렌더링"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"템플릿 렌더링"</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"애플리케이션 실행을 제어합니다."</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"애플리케이션 실행을 제어합니다."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"내 기기"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"게스트"</string>
     <string name="importance_default" msgid="8587741629268312938">"중요도가 기본인 알림 채널"</string>
diff --git a/service/res/values-ky/strings.xml b/service/res/values-ky/strings.xml
index 5a91173..eb35ce1 100644
--- a/service/res/values-ky/strings.xml
+++ b/service/res/values-ky/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Унаанын компоненттерин өчүрүү/күйгүзүү саясатын башкаруу."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"үлгүлөрдү түзүү"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Үлгүлөрдү түзүү."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"иштетилген колдонмолорду көзөмөлдөө"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Иштетилген колдонмолорду көзөмөлдөңүз."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Түзмөгүм"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Конок"</string>
     <string name="importance_default" msgid="8587741629268312938">"Демейки маанилүүлүк"</string>
diff --git a/service/res/values-lo/strings.xml b/service/res/values-lo/strings.xml
index 19f4f15..5bdf57c 100644
--- a/service/res/values-lo/strings.xml
+++ b/service/res/values-lo/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"ຄວບຄຸມນະໂຍບາຍພະລັງງານສຳລັບລົດຍົນ."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"ສະແດງແມ່ແບບ"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"ສະແດງແມ່ແບບ."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"ຄວບຄຸມການເປີດໃຊ້ແອັບພລິເຄຊັນ"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"ຄວບຄຸມການເປີດໃຊ້ແອັບພລິເຄຊັນ."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"ອຸປະກອນຂອງຂ້ອຍ"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"ແຂກ"</string>
     <string name="importance_default" msgid="8587741629268312938">"ຄວາມສຳຄັນເລີ່ມຕົ້ນ"</string>
diff --git a/service/res/values-lt/strings.xml b/service/res/values-lt/strings.xml
index 5c81219..3e83e46 100644
--- a/service/res/values-lt/strings.xml
+++ b/service/res/values-lt/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Valdyti automobilio komponentų suaktyvinimo politiką."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"Pateikti šablonus"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Pateikti šablonus."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"Valdyti paleidžiamas programas"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Valdyti paleidžiamas programas."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Mano įrenginys"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Svečias"</string>
     <string name="importance_default" msgid="8587741629268312938">"Numatytoji svarba"</string>
diff --git a/service/res/values-lv/strings.xml b/service/res/values-lv/strings.xml
index 62b697e..ae8e385 100644
--- a/service/res/values-lv/strings.xml
+++ b/service/res/values-lv/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Kontrolēt automašīnas komponentu aktivizācijas politiku."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"atveidot veidnes"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Atveidot veidnes."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"lietojumprogrammu palaišanas kontrole"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Lietojumprogrammu palaišanas kontrole."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Mana ierīce"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Viesis"</string>
     <string name="importance_default" msgid="8587741629268312938">"Noklusējuma svarīgums"</string>
diff --git a/service/res/values-mk/strings.xml b/service/res/values-mk/strings.xml
index 0680eb2..347b068 100644
--- a/service/res/values-mk/strings.xml
+++ b/service/res/values-mk/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Контролирање на правилото за напојување на автомобилот."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"прикажување шаблони"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Прикажување шаблони."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"да го контролира стартувањето апликации"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"да го контролира стартувањето апликации"</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Мојот уред"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Гостин"</string>
     <string name="importance_default" msgid="8587741629268312938">"Стандардна важност"</string>
diff --git a/service/res/values-ml/strings.xml b/service/res/values-ml/strings.xml
index 476115d..dc8dbe6 100644
--- a/service/res/values-ml/strings.xml
+++ b/service/res/values-ml/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"കാറിന്റെ പവർ പോളിസി നിയന്ത്രിക്കുക."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"ടെം‍പ്ലേറ്റുകൾ റെൻഡർ ചെയ്യുക"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"ടെം‍പ്ലേറ്റുകൾ റെൻഡർ ചെയ്യുക."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"ലോഞ്ച് ചെയ്യുന്ന ആപ്പുകൾ നിയന്ത്രിക്കാം"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"ലോഞ്ച് ചെയ്യുന്ന ആപ്പുകൾ നിയന്ത്രിക്കാം."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"എന്റെ ഉപകരണം"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"അതിഥി"</string>
     <string name="importance_default" msgid="8587741629268312938">"ഡിഫോൾട്ട് പ്രാധാന്യം"</string>
diff --git a/service/res/values-mn/strings.xml b/service/res/values-mn/strings.xml
index 9f802b6..f2c8754 100644
--- a/service/res/values-mn/strings.xml
+++ b/service/res/values-mn/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Машины асаах/унтраах бодлогыг хянана."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"загварыг буулгах"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Загварыг буулгана."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"аппликэйшн эхлүүлэхийг хянаарай"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Аппликэйшн эхлүүлэхийг хянаарай."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Миний төхөөрөмж"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Зочин"</string>
     <string name="importance_default" msgid="8587741629268312938">"Өгөгдмөл ач холбогдол"</string>
diff --git a/service/res/values-mr/strings.xml b/service/res/values-mr/strings.xml
index d5f781b..0706224 100644
--- a/service/res/values-mr/strings.xml
+++ b/service/res/values-mr/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"कार पॉवर धोरण नियंत्रित करा."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"टेम्पलेट रेंडर करा"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"टेम्पलेट रेंडर करा."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"लाँच होत असलेली अ‍ॅप्लिकेशन नियंत्रित करा"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"लाँच होत असलेली अ‍ॅप्लिकेशन नियंत्रित करा."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"माझे डिव्हाइस"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"अतिथी"</string>
     <string name="importance_default" msgid="8587741629268312938">"डीफॉल्ट महत्त्वाची"</string>
diff --git a/service/res/values-ms/strings.xml b/service/res/values-ms/strings.xml
index af016d9..54bc619 100644
--- a/service/res/values-ms/strings.xml
+++ b/service/res/values-ms/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Kawal dasar kuasa kereta."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"paparkan templat"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Paparkan templat."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"mengawal pelancaran aplikasi"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Mengawal pelancaran aplikasi."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Peranti Saya"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Tetamu"</string>
     <string name="importance_default" msgid="8587741629268312938">"Kepentingan lalai"</string>
diff --git a/service/res/values-my/strings.xml b/service/res/values-my/strings.xml
index f8b9971..5c06c6e 100644
--- a/service/res/values-my/strings.xml
+++ b/service/res/values-my/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"ကား၏စွမ်းအင်အသုံးပြုမှု မူဝါဒကို ထိန်းချုပ်မည်။"</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"နမူနာပုံစံများ ပုံဖော်ရန်"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"နမူနာပုံစံများ ပုံဖော်မည်။"</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"ဖွင့်ထားသည့် အပလီကေးရှင်းများကို ထိန်းချုပ်ခြင်း"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"ဖွင့်ထားသည့် အပလီကေးရှင်းများကို ထိန်းချုပ်ခြင်း။"</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"ကျွန်ုပ်၏စက်"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"ဧည့်သည်"</string>
     <string name="importance_default" msgid="8587741629268312938">"ပုံမှန် အရေးပါမှု"</string>
diff --git a/service/res/values-nb/strings.xml b/service/res/values-nb/strings.xml
index a11572e..9147649 100644
--- a/service/res/values-nb/strings.xml
+++ b/service/res/values-nb/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Kontrollér bilens regler for av/på."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"gjengi maler"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Gjengi maler."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"kontrollér åpning av apper"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Kontrollér åpning av apper."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Enheten min"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Gjest"</string>
     <string name="importance_default" msgid="8587741629268312938">"Standard viktighet"</string>
diff --git a/service/res/values-ne/strings.xml b/service/res/values-ne/strings.xml
index 193d32b..e91b23d 100644
--- a/service/res/values-ne/strings.xml
+++ b/service/res/values-ne/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"कारको पावरसम्बन्धी नीति नियन्त्रण गर्नुहोस्।"</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"टेम्प्लेटहरू रेन्डर गर्ने"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"टेम्प्लेटहरू रेन्डर गर्ने।"</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"एपहरू लन्च गर्ने कुरा नियन्त्रण गर्नुहोस्"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"एपहरू लन्च गर्ने कुरा नियन्त्रण गर्नुहोस्।"</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"मेरो डिभाइस"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"अतिथि"</string>
     <string name="importance_default" msgid="8587741629268312938">"डिफल्ट महत्त्व"</string>
diff --git a/service/res/values-nl/strings.xml b/service/res/values-nl/strings.xml
index 1828bd1..c3ebee5 100644
--- a/service/res/values-nl/strings.xml
+++ b/service/res/values-nl/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"In-/uitschakelbeleid voor auto beheren."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"templates renderen"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Templates renderen."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"starten van apps beheren"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Starten van apps beheren."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Mijn apparaat"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Gast"</string>
     <string name="importance_default" msgid="8587741629268312938">"Standaardbelang"</string>
diff --git a/service/res/values-or/strings.xml b/service/res/values-or/strings.xml
index ef6a1e7..c85f4b2 100644
--- a/service/res/values-or/strings.xml
+++ b/service/res/values-or/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"କାର୍ ପାୱାର୍ ନୀତି ନିୟନ୍ତ୍ରଣ କରନ୍ତୁ।"</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"ଟେମ୍ପଲେଟ୍ ରେଣ୍ଡର୍ କରନ୍ତୁ"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"ଟେମ୍ପଲେଟ୍ ରେଣ୍ଡର୍ କରନ୍ତୁ।"</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"ଆପ୍ଲିକେସନଗୁଡ଼ିକର ଲଞ୍ଚିଂକୁ ନିୟନ୍ତ୍ରଣ କରନ୍ତୁ"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"ଆପ୍ଲିକେସନଗୁଡ଼ିକର ଲଞ୍ଚିଂକୁ ନିୟନ୍ତ୍ରଣ କରନ୍ତୁ।"</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"ମୋ ଡିଭାଇସ୍"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"ଅତିଥି"</string>
     <string name="importance_default" msgid="8587741629268312938">"ଡିଫଲ୍ଟ ଗୁରୁତ୍ୱ"</string>
diff --git a/service/res/values-pa/strings.xml b/service/res/values-pa/strings.xml
index 56d461d..8882ccb 100644
--- a/service/res/values-pa/strings.xml
+++ b/service/res/values-pa/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"ਕਾਰ ਪਾਵਰ ਨੀਤੀ ਨੂੰ ਕੰਟਰੋਲ ਕਰੋ।"</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"ਟੈਮਪਲੇਟਾਂ ਨੂੰ ਰੈਂਡਰ ਕਰੋ"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"ਟੈਮਪਲੇਟਾਂ ਨੂੰ ਰੈਂਡਰ ਕਰੋ।"</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"ਲਾਂਚ ਕੀਤੀਆਂ ਜਾਣ ਵਾਲੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਕੰਟਰੋਲ ਕਰੋ"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"ਲਾਂਚ ਕੀਤੀਆਂ ਜਾਣ ਵਾਲੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਕੰਟਰੋਲ ਕਰੋ।"</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"ਮੇਰਾ ਡੀਵਾਈਸ"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"ਮਹਿਮਾਨ"</string>
     <string name="importance_default" msgid="8587741629268312938">"ਪੂਰਵ-ਨਿਰਧਾਰਿਤ ਮਹੱਤਤਾ"</string>
diff --git a/service/res/values-pl/strings.xml b/service/res/values-pl/strings.xml
index fc07c11..c5b7b48 100644
--- a/service/res/values-pl/strings.xml
+++ b/service/res/values-pl/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Sterowanie zasadami zasilania samochodu."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"renderowanie szablonów"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Renderowanie szablonów."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"kontrola nad uruchamianiem aplikacji"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Kontrola nad uruchamianiem aplikacji."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Moje urządzenie"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Gość"</string>
     <string name="importance_default" msgid="8587741629268312938">"Domyślny stopień ważności"</string>
diff --git a/service/res/values-pt-rPT/strings.xml b/service/res/values-pt-rPT/strings.xml
index 30384cb..4fcbafd 100644
--- a/service/res/values-pt-rPT/strings.xml
+++ b/service/res/values-pt-rPT/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Controlar a política de energia do automóvel."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"renderizar modelos"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Renderizar modelos."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"controlar o início de aplicações"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Controlar o início de aplicações."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Dispositivo"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Convidado"</string>
     <string name="importance_default" msgid="8587741629268312938">"Importância predefinida"</string>
diff --git a/service/res/values-pt/strings.xml b/service/res/values-pt/strings.xml
index 2fee366..15a9614 100644
--- a/service/res/values-pt/strings.xml
+++ b/service/res/values-pt/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Controle a política de energia do carro."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"renderizar modelos"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Renderizar modelos."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"controla a inicialização de aplicativos"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Controla a inicialização de aplicativos."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Meu dispositivo"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Visitante"</string>
     <string name="importance_default" msgid="8587741629268312938">"Importância padrão"</string>
diff --git a/service/res/values-ro/strings.xml b/service/res/values-ro/strings.xml
index 1a8bbde..3cc5c30 100644
--- a/service/res/values-ro/strings.xml
+++ b/service/res/values-ro/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Controlați politica pentru încărcarea mașinii."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"redați șabloane"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Redați șabloane."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"să controleze aplicațiile lansate"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Controlează aplicațiile lansate."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Dispozitivul meu"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Invitat"</string>
     <string name="importance_default" msgid="8587741629268312938">"Importanță prestabilită"</string>
diff --git a/service/res/values-ru/strings.xml b/service/res/values-ru/strings.xml
index 5de2860..db6d212 100644
--- a/service/res/values-ru/strings.xml
+++ b/service/res/values-ru/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Управление правилом о питании автомобиля."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"Обработка шаблонов"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Обработка шаблонов."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"управление запуском приложений"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Управление запуском приложений."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Мое устройство"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Гость"</string>
     <string name="importance_default" msgid="8587741629268312938">"Важность по умолчанию"</string>
diff --git a/service/res/values-si/strings.xml b/service/res/values-si/strings.xml
index 9e63f6c..ba49280 100644
--- a/service/res/values-si/strings.xml
+++ b/service/res/values-si/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"මෝටර් රථයේ බල ප්‍රතිපත්තිය පාලනය කරන්න."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"අච්චු විදහන්න"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"අච්චු විදහන්න."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"යෙදුම් දියත් කිරීම කළමනාකරණය කරන්න"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"යෙදුම් දියත් කිරීම කළමනාකරණය කරන්න."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"මගේ උපාංගය"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"අමුත්තා"</string>
     <string name="importance_default" msgid="8587741629268312938">"පෙරනිමි වැදගත්කම"</string>
diff --git a/service/res/values-sk/strings.xml b/service/res/values-sk/strings.xml
index c5927cc..c87b3e2 100644
--- a/service/res/values-sk/strings.xml
+++ b/service/res/values-sk/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Ovládanie pravidiel pre napájanie komponentov auta."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"vykresľovanie šablón"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Vykresľovanie šablón."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"ovládanie spúšťaných aplikácií"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Ovládanie spúšťaných aplikácií."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Moje zariadenie"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Hosť"</string>
     <string name="importance_default" msgid="8587741629268312938">"Predvolená dôležitosť"</string>
diff --git a/service/res/values-sl/strings.xml b/service/res/values-sl/strings.xml
index 9662ac4..a734675 100644
--- a/service/res/values-sl/strings.xml
+++ b/service/res/values-sl/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Nadziranje pravilnika o delovanju komponent v avtomobilu."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"upodabljanje predlog"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Upodabljanje predlog."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"nadziranje zaganjanja aplikacij"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Nadziranje zaganjanja aplikacij"</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Moja naprava"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Gost"</string>
     <string name="importance_default" msgid="8587741629268312938">"Privzeta pomembnost"</string>
diff --git a/service/res/values-sq/strings.xml b/service/res/values-sq/strings.xml
index 2bdaaa1..4f5a17e 100644
--- a/service/res/values-sq/strings.xml
+++ b/service/res/values-sq/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Kontrollo politikën e makinës për aktivizimin."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"të paraqesë shabllonet"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Të paraqesë shabllonet."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"kontrollo hapjen e aplikacioneve"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Kontrollo hapjen e aplikacioneve."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Pajisja ime"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"I ftuar"</string>
     <string name="importance_default" msgid="8587741629268312938">"Rëndësia e parazgjedhur"</string>
diff --git a/service/res/values-sr/strings.xml b/service/res/values-sr/strings.xml
index 5e69d4f..d8b88f8 100644
--- a/service/res/values-sr/strings.xml
+++ b/service/res/values-sr/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Контрола смерница за напајање аутомобила."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"приказивање шаблона"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Приказивање шаблона."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"контрола покретања апликација"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Контролише покретање апликација."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Мој уређај"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Гост"</string>
     <string name="importance_default" msgid="8587741629268312938">"Подразумевана важност"</string>
diff --git a/service/res/values-sv/strings.xml b/service/res/values-sv/strings.xml
index 653bc81..a485cd7 100644
--- a/service/res/values-sv/strings.xml
+++ b/service/res/values-sv/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Styr principer för bilens laddning."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"rendera mallar"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Rendera mallar."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"styr startande appar"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Styr startande appar."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Min enhet"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Gäst"</string>
     <string name="importance_default" msgid="8587741629268312938">"Standardviktighet"</string>
diff --git a/service/res/values-sw/strings.xml b/service/res/values-sw/strings.xml
index dee4351..43a1353 100644
--- a/service/res/values-sw/strings.xml
+++ b/service/res/values-sw/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Dhibiti sera ya nishati ya gari."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"kutekeleza violezo"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Kutekeleza violezo."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"kudhibiti programu za kufungua"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Dhibiti programu za kufungua."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Kifaa Changu"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Mgeni"</string>
     <string name="importance_default" msgid="8587741629268312938">"Umuhimu wa kiwango cha chaguomsingi"</string>
diff --git a/service/res/values-ta/strings.xml b/service/res/values-ta/strings.xml
index 0f468bd..4cb6282 100644
--- a/service/res/values-ta/strings.xml
+++ b/service/res/values-ta/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"காரின் பவர் கொள்கையைக் கட்டுப்படுத்தும்."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"டெம்ப்ளேட்டுகளைக் காட்டுதல்"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"டெம்ப்ளேட்டுகளைக் காட்டுதல்."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"தொடங்கும் ஆப்ஸைக் கட்டுப்படுத்தலாம்"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"தொடங்கும் ஆப்ஸைக் கட்டுப்படுத்தலாம்."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"எனது சாதனம்"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"விருந்தினர்"</string>
     <string name="importance_default" msgid="8587741629268312938">"இயல்புநிலை முக்கியத்துவம்"</string>
diff --git a/service/res/values-te/strings.xml b/service/res/values-te/strings.xml
index 30ab4e3..c3b3c42 100644
--- a/service/res/values-te/strings.xml
+++ b/service/res/values-te/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"కారు పవర్ పాలసీని కంట్రోల్ చేయండి."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"టెంప్లేట్‌లను రెండర్ చేస్తుంది"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"టెంప్లేట్‌లను రెండర్ చేస్తుంది."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"లాంచ్ చేయబడుతున్న యాప్‌లను కంట్రోల్ చేయండి"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"లాంచ్ చేయబడుతున్న యాప్‌లను కంట్రోల్ చేయండి."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"నా పరికరం"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"అతిథి"</string>
     <string name="importance_default" msgid="8587741629268312938">"ప్రాముఖ్యత ఆటోమేటిక్ సెట్టింగ్‌గా ఉన్నది"</string>
diff --git a/service/res/values-th/strings.xml b/service/res/values-th/strings.xml
index 01dd0e0..90d0629 100644
--- a/service/res/values-th/strings.xml
+++ b/service/res/values-th/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"ควบคุมนโยบายทางไฟฟ้าสำหรับรถยนต์"</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"แสดงผลเทมเพลต"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"แสดงผลเทมเพลต"</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"ควบคุมการเปิดใช้งานแอปพลิเคชัน"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"ควบคุมการเปิดใช้งานแอปพลิเคชัน"</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"อุปกรณ์ของฉัน"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"ผู้มาเยือน"</string>
     <string name="importance_default" msgid="8587741629268312938">"ความสำคัญเริ่มต้น"</string>
diff --git a/service/res/values-tl/strings.xml b/service/res/values-tl/strings.xml
index 8d8a259..dcb6b85 100644
--- a/service/res/values-tl/strings.xml
+++ b/service/res/values-tl/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Kontrolin ang patakaran sa power ng kotse."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"mag-render nga template"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Mag-render ng mga template."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"kontrolin ang paglunsad ng mga application"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Kontrolin ang paglunsad ng mga application."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Aking Device"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Bisita"</string>
     <string name="importance_default" msgid="8587741629268312938">"Default na halaga"</string>
diff --git a/service/res/values-tr/strings.xml b/service/res/values-tr/strings.xml
index 9fb6a42..d21eccb 100644
--- a/service/res/values-tr/strings.xml
+++ b/service/res/values-tr/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Araba gücü politikasını kontrol edin."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"şablonları oluşturma"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Şablonları oluşturma."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"başlatılan uygulamaları kontrol etme"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Başlatılan uygulamaları kontrol etme."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Cihazım"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Misafir"</string>
     <string name="importance_default" msgid="8587741629268312938">"Varsayılan önem"</string>
diff --git a/service/res/values-uk/strings.xml b/service/res/values-uk/strings.xml
index 18fa873..bd19473 100644
--- a/service/res/values-uk/strings.xml
+++ b/service/res/values-uk/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Керувати правилами щодо ввімкнення компонентів автомобіля."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"відображати шаблони"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Відображати шаблони."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"керувати додатками, що запускаються"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Керувати додатками, що запускаються."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Мій пристрій"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Гість"</string>
     <string name="importance_default" msgid="8587741629268312938">"Пріоритет за умовчанням"</string>
diff --git a/service/res/values-ur/strings.xml b/service/res/values-ur/strings.xml
index 14063b8..dce0c35 100644
--- a/service/res/values-ur/strings.xml
+++ b/service/res/values-ur/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"کار کے پاور کی پالیسی کو کنٹرول کریں۔"</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"تمثیلات تیار کریں"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"تمثیلات تیار کریں۔"</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"شروع ہونے والی ایپلیکیشنز کو کنٹرول کریں"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"شروع ہونے والی ایپلیکیشنز کو کنٹرول کریں۔"</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"میرا آلہ"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"مہمان"</string>
     <string name="importance_default" msgid="8587741629268312938">"ڈیفالٹ اہمیت"</string>
diff --git a/service/res/values-uz/strings.xml b/service/res/values-uz/strings.xml
index ed419c5..3cb2dde 100644
--- a/service/res/values-uz/strings.xml
+++ b/service/res/values-uz/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Avtomobilning yoqish qoidalarini boshqarish."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"andozalarni renderlash"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Andozalarni renderlash."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"ilovani ishga tushirishni boshqarish"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Ilovani ishga tushirishni boshqarish."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Qurilmam"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Mehmon"</string>
     <string name="importance_default" msgid="8587741629268312938">"Birlamchi muhimlik"</string>
diff --git a/service/res/values-vi/strings.xml b/service/res/values-vi/strings.xml
index 68df7d3..74f6090 100644
--- a/service/res/values-vi/strings.xml
+++ b/service/res/values-vi/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Kiểm soát nguyên tắc sử dụng điện của ô tô."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"mẫu kết xuất hình ảnh"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Mẫu kết xuất hình ảnh."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"kiểm soát việc mở ứng dụng"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Kiểm soát việc mở ứng dụng."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Thiết bị của tôi"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Khách"</string>
     <string name="importance_default" msgid="8587741629268312938">"Tầm quan trọng mặc định"</string>
diff --git a/service/res/values-zh-rCN/strings.xml b/service/res/values-zh-rCN/strings.xml
index cc1f8ce..236297e 100644
--- a/service/res/values-zh-rCN/strings.xml
+++ b/service/res/values-zh-rCN/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"控制汽车电源政策。"</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"渲染模板"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"渲染模板。"</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"控制应用启动"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"控制应用启动。"</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"我的设备"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"访客"</string>
     <string name="importance_default" msgid="8587741629268312938">"重要性：默认"</string>
diff --git a/service/res/values-zh-rHK/strings.xml b/service/res/values-zh-rHK/strings.xml
index 64824fa..6445c69 100644
--- a/service/res/values-zh-rHK/strings.xml
+++ b/service/res/values-zh-rHK/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"控制汽車能源政策。"</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"輸出範本"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"輸出範本。"</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"控制啟動應用程式"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"控制啟動應用程式。"</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"我的裝置"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"訪客"</string>
     <string name="importance_default" msgid="8587741629268312938">"預設重要性"</string>
diff --git a/service/res/values-zh-rTW/strings.xml b/service/res/values-zh-rTW/strings.xml
index a85efcc..8af0c44 100644
--- a/service/res/values-zh-rTW/strings.xml
+++ b/service/res/values-zh-rTW/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"控制車輛電源政策。"</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"算繪範本"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"算繪範本。"</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"控制要啟動的應用程式"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"控制要啟動的應用程式。"</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"我的裝置"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"訪客"</string>
     <string name="importance_default" msgid="8587741629268312938">"預設重要性"</string>
diff --git a/service/res/values-zu/strings.xml b/service/res/values-zu/strings.xml
index cdcdca7..2e9feea 100644
--- a/service/res/values-zu/strings.xml
+++ b/service/res/values-zu/strings.xml
@@ -169,10 +169,8 @@
     <string name="car_permission_desc_control_car_power_policy" msgid="8565782440893507028">"Lawula inqubomgomo yamandla emoto."</string>
     <string name="car_permission_label_template_renderer" msgid="3464887382919754850">"nikezela izifanekiso"</string>
     <string name="car_permission_desc_template_renderer" msgid="6047233999260920122">"Nikezela izifanekiso."</string>
-    <!-- no translation found for car_permission_label_control_car_app_launch (214632389637409226) -->
-    <skip />
-    <!-- no translation found for car_permission_desc_control_car_app_launch (4245527461733374198) -->
-    <skip />
+    <string name="car_permission_label_control_car_app_launch" msgid="214632389637409226">"lawula ama-application okuqalisa"</string>
+    <string name="car_permission_desc_control_car_app_launch" msgid="4245527461733374198">"Lawula ama-application okuqalisa."</string>
     <string name="trust_device_default_name" msgid="4213625926070261253">"Idivayisi yami"</string>
     <string name="default_guest_name" msgid="2912812799433131476">"Isihambeli"</string>
     <string name="importance_default" msgid="8587741629268312938">"Ukubaluleka okuzenzakalelayo"</string>
diff --git a/service/src/com/android/car/telemetry/CarTelemetryService.java b/service/src/com/android/car/telemetry/CarTelemetryService.java
index 6f5ca1a..05dd708 100644
--- a/service/src/com/android/car/telemetry/CarTelemetryService.java
+++ b/service/src/com/android/car/telemetry/CarTelemetryService.java
@@ -31,7 +31,6 @@
 import android.os.PersistableBundle;
 import android.os.RemoteException;
 import android.util.IndentingPrintWriter;
-import android.util.Slog;
 
 import com.android.car.CarLocalServices;
 import com.android.car.CarLog;
@@ -47,6 +46,7 @@
 import com.android.car.telemetry.publisher.StatsManagerProxy;
 import com.android.car.telemetry.systemmonitor.SystemMonitor;
 import com.android.internal.annotations.VisibleForTesting;
+import com.android.server.utils.Slogf;
 
 import com.google.protobuf.InvalidProtocolBufferException;
 
@@ -126,7 +126,7 @@
                 Car.PERMISSION_USE_CAR_TELEMETRY_SERVICE, "setListener");
         mTelemetryHandler.post(() -> {
             if (DEBUG) {
-                Slog.d(CarLog.TAG_TELEMETRY, "Setting the listener for car telemetry service");
+                Slogf.d(CarLog.TAG_TELEMETRY, "Setting the listener for car telemetry service");
             }
             mListener = listener;
         });
@@ -141,7 +141,7 @@
                 Car.PERMISSION_USE_CAR_TELEMETRY_SERVICE, "clearListener");
         mTelemetryHandler.post(() -> {
             if (DEBUG) {
-                Slog.d(CarLog.TAG_TELEMETRY, "Clearing the listener for car telemetry service");
+                Slogf.d(CarLog.TAG_TELEMETRY, "Clearing the listener for car telemetry service");
             }
             mListener = null;
         });
@@ -160,17 +160,17 @@
                 Car.PERMISSION_USE_CAR_TELEMETRY_SERVICE, "addMetricsConfig");
         mTelemetryHandler.post(() -> {
             if (mListener == null) {
-                Slog.w(CarLog.TAG_TELEMETRY, "ICarTelemetryServiceListener is not set");
+                Slogf.w(CarLog.TAG_TELEMETRY, "ICarTelemetryServiceListener is not set");
                 return;
             }
-            Slog.d(CarLog.TAG_TELEMETRY, "Adding metrics config " + key.getName()
+            Slogf.d(CarLog.TAG_TELEMETRY, "Adding metrics config " + key.getName()
                     + " to car telemetry service");
             TelemetryProto.MetricsConfig metricsConfig = null;
             int status = ERROR_METRICS_CONFIG_UNKNOWN;
             try {
                 metricsConfig = TelemetryProto.MetricsConfig.parseFrom(config);
             } catch (InvalidProtocolBufferException e) {
-                Slog.e(CarLog.TAG_TELEMETRY, "Failed to parse MetricsConfig.", e);
+                Slogf.e(CarLog.TAG_TELEMETRY, "Failed to parse MetricsConfig.", e);
                 status = ERROR_METRICS_CONFIG_PARSE_FAILED;
             }
             // if config can be parsed, add it to persistent storage
@@ -187,7 +187,7 @@
             try {
                 mListener.onAddMetricsConfigStatus(key, status);
             } catch (RemoteException e) {
-                Slog.w(CarLog.TAG_TELEMETRY, "error with ICarTelemetryServiceListener", e);
+                Slogf.w(CarLog.TAG_TELEMETRY, "error with ICarTelemetryServiceListener", e);
             }
         });
     }
@@ -203,7 +203,7 @@
         mContext.enforceCallingOrSelfPermission(
                 Car.PERMISSION_USE_CAR_TELEMETRY_SERVICE, "removeMetricsConfig");
         mTelemetryHandler.post(() -> {
-            Slog.d(CarLog.TAG_TELEMETRY, "Removing metrics config " + key.getName()
+            Slogf.d(CarLog.TAG_TELEMETRY, "Removing metrics config " + key.getName()
                     + " from car telemetry service");
             // TODO(b/198792767): Check both config name and config version for removal
             mDataBroker.removeMetricsConfiguration(key.getName());
@@ -220,7 +220,7 @@
         mContext.enforceCallingOrSelfPermission(
                 Car.PERMISSION_USE_CAR_TELEMETRY_SERVICE, "removeAllMetricsConfigs");
         mTelemetryHandler.post(() -> {
-            Slog.d(CarLog.TAG_TELEMETRY,
+            Slogf.d(CarLog.TAG_TELEMETRY,
                     "Removing all metrics config from car telemetry service");
             mDataBroker.removeAllMetricsConfigurations();
             mMetricsConfigStore.removeAllMetricsConfigs();
@@ -241,11 +241,11 @@
                 Car.PERMISSION_USE_CAR_TELEMETRY_SERVICE, "sendFinishedReports");
         mTelemetryHandler.post(() -> {
             if (mListener == null) {
-                Slog.w(CarLog.TAG_TELEMETRY, "ICarTelemetryServiceListener is not set");
+                Slogf.w(CarLog.TAG_TELEMETRY, "ICarTelemetryServiceListener is not set");
                 return;
             }
             if (DEBUG) {
-                Slog.d(CarLog.TAG_TELEMETRY,
+                Slogf.d(CarLog.TAG_TELEMETRY,
                         "Flushing reports for metrics config " + key.getName());
             }
             PersistableBundle result = mResultStore.getFinalResult(key.getName(), true);
@@ -255,7 +255,7 @@
             } else if (error != null) {
                 sendError(key, error);
             } else {
-                Slog.w(CarLog.TAG_TELEMETRY, "config " + key.getName()
+                Slogf.w(CarLog.TAG_TELEMETRY, "config " + key.getName()
                         + " did not produce any results");
             }
         });
@@ -270,7 +270,7 @@
         mContext.enforceCallingOrSelfPermission(
                 Car.PERMISSION_USE_CAR_TELEMETRY_SERVICE, "sendAllFinishedReports");
         if (DEBUG) {
-            Slog.d(CarLog.TAG_TELEMETRY, "Flushing all reports");
+            Slogf.d(CarLog.TAG_TELEMETRY, "Flushing all reports");
         }
     }
 
@@ -279,9 +279,9 @@
             result.writeToStream(bos);
             mListener.onResult(key, bos.toByteArray());
         } catch (RemoteException e) {
-            Slog.w(CarLog.TAG_TELEMETRY, "error with ICarTelemetryServiceListener", e);
+            Slogf.w(CarLog.TAG_TELEMETRY, "error with ICarTelemetryServiceListener", e);
         } catch (IOException e) {
-            Slog.w(CarLog.TAG_TELEMETRY, "failed to write bundle to output stream", e);
+            Slogf.w(CarLog.TAG_TELEMETRY, "failed to write bundle to output stream", e);
         }
     }
 
@@ -289,7 +289,7 @@
         try {
             mListener.onError(key, error.toByteArray());
         } catch (RemoteException e) {
-            Slog.w(CarLog.TAG_TELEMETRY, "error with ICarTelemetryServiceListener", e);
+            Slogf.w(CarLog.TAG_TELEMETRY, "error with ICarTelemetryServiceListener", e);
         }
     }
 
diff --git a/service/src/com/android/car/telemetry/MetricsConfigStore.java b/service/src/com/android/car/telemetry/MetricsConfigStore.java
index 2d259d4..dc04927 100644
--- a/service/src/com/android/car/telemetry/MetricsConfigStore.java
+++ b/service/src/com/android/car/telemetry/MetricsConfigStore.java
@@ -22,10 +22,10 @@
 import static android.car.telemetry.CarTelemetryManager.ERROR_METRICS_CONFIG_VERSION_TOO_OLD;
 
 import android.util.ArrayMap;
-import android.util.Slog;
 
 import com.android.car.CarLog;
 import com.android.internal.annotations.VisibleForTesting;
+import com.android.server.utils.Slogf;
 
 import java.io.File;
 import java.io.IOException;
@@ -97,7 +97,7 @@
                     metricsConfig.toByteArray());
         } catch (IOException e) {
             // TODO(b/197336655): record failure
-            Slog.w(CarLog.TAG_TELEMETRY, "Failed to write metrics config to disk", e);
+            Slogf.w(CarLog.TAG_TELEMETRY, "Failed to write metrics config to disk", e);
             return ERROR_METRICS_CONFIG_UNKNOWN;
         }
         return ERROR_METRICS_CONFIG_NONE;
@@ -108,7 +108,7 @@
         mActiveConfigs.remove(metricsConfigName);
         mNameVersionMap.remove(metricsConfigName);
         if (!new File(mConfigDirectory, metricsConfigName).delete()) {
-            Slog.w(CarLog.TAG_TELEMETRY, "Failed to remove MetricsConfig: " + metricsConfigName);
+            Slogf.w(CarLog.TAG_TELEMETRY, "Failed to remove MetricsConfig: " + metricsConfigName);
         }
     }
 
@@ -117,7 +117,7 @@
         mActiveConfigs.clear();
         for (File file : mConfigDirectory.listFiles()) {
             if (!file.delete()) {
-                Slog.w(CarLog.TAG_TELEMETRY, "Failed to remove MetricsConfig: " + file.getName());
+                Slogf.w(CarLog.TAG_TELEMETRY, "Failed to remove MetricsConfig: " + file.getName());
             }
         }
     }
diff --git a/service/src/com/android/car/telemetry/ResultStore.java b/service/src/com/android/car/telemetry/ResultStore.java
index 85aa23e..c4deca4 100644
--- a/service/src/com/android/car/telemetry/ResultStore.java
+++ b/service/src/com/android/car/telemetry/ResultStore.java
@@ -18,10 +18,10 @@
 
 import android.os.PersistableBundle;
 import android.util.ArrayMap;
-import android.util.Slog;
 
 import com.android.car.CarLog;
 import com.android.internal.annotations.VisibleForTesting;
+import com.android.server.utils.Slogf;
 
 import java.io.File;
 import java.io.FileInputStream;
@@ -72,7 +72,7 @@
                         file.getName(),
                         new InterimResult(PersistableBundle.readFromStream(fis)));
             } catch (IOException e) {
-                Slog.w(CarLog.TAG_TELEMETRY, "Failed to read result from disk.", e);
+                Slogf.w(CarLog.TAG_TELEMETRY, "Failed to read result from disk.", e);
                 // TODO(b/197153560): record failure
             }
         }
@@ -115,7 +115,7 @@
         try (FileInputStream fis = new FileInputStream(file)) {
             result = PersistableBundle.readFromStream(fis);
         } catch (IOException e) {
-            Slog.w(CarLog.TAG_TELEMETRY, "Failed to get final result from disk.", e);
+            Slogf.w(CarLog.TAG_TELEMETRY, "Failed to get final result from disk.", e);
         }
         if (deleteResult) {
             file.delete();
@@ -146,7 +146,7 @@
             byte[] serializedBytes = Files.readAllBytes(file.toPath());
             result = TelemetryProto.TelemetryError.parseFrom(serializedBytes);
         } catch (IOException e) {
-            Slog.w(CarLog.TAG_TELEMETRY, "Failed to get error result from disk.", e);
+            Slogf.w(CarLog.TAG_TELEMETRY, "Failed to get error result from disk.", e);
         }
         if (deleteResult) {
             file.delete();
@@ -164,7 +164,7 @@
             deleteFileInDirectory(mInterimResultDirectory, metricsConfigName);
             mInterimResultCache.remove(metricsConfigName);
         } catch (IOException e) {
-            Slog.w(CarLog.TAG_TELEMETRY, "Failed to write data to file", e);
+            Slogf.w(CarLog.TAG_TELEMETRY, "Failed to write data to file", e);
             // TODO(b/197153560): record failure
         }
     }
@@ -229,7 +229,7 @@
         try (FileOutputStream os = new FileOutputStream(new File(dir, metricsConfigName))) {
             result.writeToStream(os);
         } catch (IOException e) {
-            Slog.w(CarLog.TAG_TELEMETRY, "Failed to write result to file", e);
+            Slogf.w(CarLog.TAG_TELEMETRY, "Failed to write result to file", e);
             // TODO(b/197153560): record failure
         }
     }
diff --git a/service/src/com/android/car/telemetry/databroker/DataBrokerImpl.java b/service/src/com/android/car/telemetry/databroker/DataBrokerImpl.java
index 94f1b11..153b4a8 100644
--- a/service/src/com/android/car/telemetry/databroker/DataBrokerImpl.java
+++ b/service/src/com/android/car/telemetry/databroker/DataBrokerImpl.java
@@ -30,7 +30,6 @@
 import android.os.RemoteException;
 import android.os.UserHandle;
 import android.util.ArrayMap;
-import android.util.Slog;
 
 import com.android.car.CarLog;
 import com.android.car.CarServiceUtils;
@@ -43,6 +42,7 @@
 import com.android.car.telemetry.scriptexecutorinterface.IScriptExecutor;
 import com.android.car.telemetry.scriptexecutorinterface.IScriptExecutorListener;
 import com.android.internal.annotations.VisibleForTesting;
+import com.android.server.utils.Slogf;
 
 import java.io.Closeable;
 import java.io.IOException;
@@ -150,7 +150,7 @@
             AbstractPublisher publisher, List<TelemetryProto.MetricsConfig> affectedConfigs,
             Throwable error) {
         // TODO(b/193680465): disable MetricsConfig and log the error
-        Slog.w(CarLog.TAG_TELEMETRY, "publisher failed", error);
+        Slogf.w(CarLog.TAG_TELEMETRY, "publisher failed", error);
     }
 
     private void bindScriptExecutor() {
@@ -172,13 +172,13 @@
         unbindScriptExecutor();
         mBindScriptExecutorAttempts++;
         if (mBindScriptExecutorAttempts < MAX_BIND_SCRIPT_EXECUTOR_ATTEMPTS) {
-            Slog.w(CarLog.TAG_TELEMETRY,
+            Slogf.w(CarLog.TAG_TELEMETRY,
                     "failed to get valid connection to ScriptExecutor, retrying in "
                             + mBindScriptExecutorDelayMillis + "ms.");
             mTelemetryHandler.sendEmptyMessageDelayed(MSG_BIND_TO_SCRIPT_EXECUTOR,
                     mBindScriptExecutorDelayMillis);
         } else {
-            Slog.w(CarLog.TAG_TELEMETRY, "failed to get valid connection to ScriptExecutor, "
+            Slogf.w(CarLog.TAG_TELEMETRY, "failed to get valid connection to ScriptExecutor, "
                     + "disabling DataBroker");
             disableBroker();
         }
@@ -195,7 +195,7 @@
             mContext.unbindService(mServiceConnection);
         } catch (IllegalArgumentException e) {
             // If ScriptExecutor is gone before unbinding, it will throw this exception
-            Slog.w(CarLog.TAG_TELEMETRY, "Failed to unbind from ScriptExecutor", e);
+            Slogf.w(CarLog.TAG_TELEMETRY, "Failed to unbind from ScriptExecutor", e);
         }
     }
 
@@ -242,7 +242,7 @@
                 // TODO(b/191378559): handle bad configs
                 publisher.addDataSubscriber(dataSubscriber);
             } catch (IllegalArgumentException e) {
-                Slog.w(CarLog.TAG_TELEMETRY, "Invalid config", e);
+                Slogf.w(CarLog.TAG_TELEMETRY, "Invalid config", e);
                 return;
             }
         }
@@ -265,7 +265,7 @@
                 publisher.removeDataSubscriber(subscriber);
             } catch (IllegalArgumentException e) {
                 // It shouldn't happen, but if happens, let's just log it.
-                Slog.w(CarLog.TAG_TELEMETRY, "Failed to remove subscriber from publisher", e);
+                Slogf.w(CarLog.TAG_TELEMETRY, "Failed to remove subscriber from publisher", e);
             }
         }
         // Remove all the tasks associated with this metrics config. The underlying impl uses the
@@ -359,7 +359,7 @@
         }
         // if script executor is null, bind service
         if (mScriptExecutor == null) {
-            Slog.w(CarLog.TAG_TELEMETRY,
+            Slogf.w(CarLog.TAG_TELEMETRY,
                     "script executor is null, cannot execute task");
             // upon successful binding, a task will be scheduled to run if there are any
             mTelemetryHandler.sendEmptyMessage(MSG_BIND_TO_SCRIPT_EXECUTOR);
@@ -370,10 +370,10 @@
         mCurrentScriptName = task.getMetricsConfig().getName();
         try {
             if (task.getDataSizeBytes() >= LARGE_SCRIPT_INPUT_SIZE_BYTES) {
-                Slog.d(CarLog.TAG_TELEMETRY, "invoking script executor for large input");
+                Slogf.d(CarLog.TAG_TELEMETRY, "invoking script executor for large input");
                 invokeScriptForLargeInput(task);
             } else {
-                Slog.d(CarLog.TAG_TELEMETRY, "invoking script executor");
+                Slogf.d(CarLog.TAG_TELEMETRY, "invoking script executor");
                 mScriptExecutor.invokeScript(
                         task.getMetricsConfig().getScript(),
                         task.getHandlerName(),
@@ -382,11 +382,11 @@
                         mScriptExecutorListener);
             }
         } catch (RemoteException e) {
-            Slog.w(CarLog.TAG_TELEMETRY, "remote exception occurred invoking script", e);
+            Slogf.w(CarLog.TAG_TELEMETRY, "remote exception occurred invoking script", e);
             unbindScriptExecutor();
             addTaskToQueue(task); // will trigger scheduleNextTask() and re-binding scriptexecutor
         } catch (IOException e) {
-            Slog.w(CarLog.TAG_TELEMETRY, "Either unable to create pipe or failed to pipe data"
+            Slogf.w(CarLog.TAG_TELEMETRY, "Either unable to create pipe or failed to pipe data"
                     + " to ScriptExecutor. Skipping the published data", e);
             mCurrentScriptName = null;
             scheduleNextTask(); // drop this task and schedule the next one
@@ -420,7 +420,7 @@
         }
         closeQuietly(readFd);
 
-        Slog.d(CarLog.TAG_TELEMETRY, "writing large script data to pipe");
+        Slogf.d(CarLog.TAG_TELEMETRY, "writing large script data to pipe");
         try (OutputStream outputStream = new ParcelFileDescriptor.AutoCloseOutputStream(writeFd)) {
             task.getData().writeToStream(outputStream);
         }
@@ -528,7 +528,7 @@
                     bindScriptExecutor();
                     break;
                 default:
-                    Slog.w(CarLog.TAG_TELEMETRY, "TaskHandler received unknown message.");
+                    Slogf.w(CarLog.TAG_TELEMETRY, "TaskHandler received unknown message.");
             }
         }
     }
diff --git a/service/src/com/android/car/telemetry/publisher/CarTelemetrydPublisher.java b/service/src/com/android/car/telemetry/publisher/CarTelemetrydPublisher.java
index c71e728..282838d 100644
--- a/service/src/com/android/car/telemetry/publisher/CarTelemetrydPublisher.java
+++ b/service/src/com/android/car/telemetry/publisher/CarTelemetrydPublisher.java
@@ -23,7 +23,6 @@
 import android.os.IBinder;
 import android.os.RemoteException;
 import android.os.ServiceManager;
-import android.util.Slog;
 
 import com.android.automotive.telemetry.CarDataProto;
 import com.android.car.CarLog;
@@ -61,7 +60,7 @@
         @Override
         public void onCarDataReceived(final CarDataInternal[] dataList) throws RemoteException {
             if (DEBUG) {
-                Slog.d(CarLog.TAG_TELEMETRY,
+                Slogf.d(CarLog.TAG_TELEMETRY,
                         "Received " + dataList.length + " CarData from cartelemetryd");
             }
             // TODO(b/189142577): Create custom Handler and post message to improve performance
@@ -143,7 +142,7 @@
         try {
             mCarTelemetryInternal.clearListener();
         } catch (RemoteException e) {
-            Slog.w(CarLog.TAG_TELEMETRY, "Failed to remove ICarTelemetryInternal listener", e);
+            Slogf.w(CarLog.TAG_TELEMETRY, "Failed to remove ICarTelemetryInternal listener", e);
         }
         mCarTelemetryInternal.asBinder().unlinkToDeath(this::onBinderDied, BINDER_FLAGS);
         mCarTelemetryInternal = null;
diff --git a/service/src/com/android/car/telemetry/publisher/StatsPublisher.java b/service/src/com/android/car/telemetry/publisher/StatsPublisher.java
index 98406dc..be335e9 100644
--- a/service/src/com/android/car/telemetry/publisher/StatsPublisher.java
+++ b/service/src/com/android/car/telemetry/publisher/StatsPublisher.java
@@ -25,7 +25,6 @@
 import android.os.PersistableBundle;
 import android.os.Process;
 import android.util.LongSparseArray;
-import android.util.Slog;
 
 import com.android.car.CarLog;
 import com.android.car.telemetry.AtomsProto;
@@ -39,6 +38,7 @@
 import com.android.car.telemetry.publisher.statsconverters.StatsConversionException;
 import com.android.internal.annotations.VisibleForTesting;
 import com.android.internal.util.Preconditions;
+import com.android.server.utils.Slogf;
 
 import com.google.protobuf.InvalidProtocolBufferException;
 
@@ -149,7 +149,7 @@
             return new PersistableBundle();
         } catch (IOException e) {
             // TODO(b/199947533): handle failure
-            Slog.e(CarLog.TAG_TELEMETRY,
+            Slogf.e(CarLog.TAG_TELEMETRY,
                     "Failed to read file " + mSavedStatsConfigsFile.getAbsolutePath(), e);
             return new PersistableBundle();
         }
@@ -165,7 +165,7 @@
             mSavedStatsConfigs.writeToStream(fileOutputStream);
         } catch (IOException e) {
             // TODO(b/199947533): handle failure
-            Slog.e(CarLog.TAG_TELEMETRY,
+            Slogf.e(CarLog.TAG_TELEMETRY,
                     "Cannot write to " + mSavedStatsConfigsFile.getAbsolutePath()
                             + ". Added stats config info is lost.", e);
         }
@@ -182,7 +182,7 @@
         mConfigKeyToSubscribers.put(configKey, subscriber);
         addStatsConfig(configKey, subscriber);
         if (!mIsPullingReports) {
-            Slog.d(CarLog.TAG_TELEMETRY, "Stats report will be pulled in "
+            Slogf.d(CarLog.TAG_TELEMETRY, "Stats report will be pulled in "
                     + PULL_REPORTS_PERIOD.toMinutes() + " minutes.");
             mIsPullingReports = true;
             mTelemetryHandler.postDelayed(
@@ -191,20 +191,20 @@
     }
 
     private void processReport(long configKey, StatsLogProto.ConfigMetricsReportList report) {
-        Slog.i(CarLog.TAG_TELEMETRY, "Received reports: " + report.getReportsCount());
+        Slogf.i(CarLog.TAG_TELEMETRY, "Received reports: " + report.getReportsCount());
         if (report.getReportsCount() == 0) {
             return;
         }
         DataSubscriber subscriber = mConfigKeyToSubscribers.get(configKey);
         if (subscriber == null) {
-            Slog.w(CarLog.TAG_TELEMETRY, "No subscribers found for config " + configKey);
+            Slogf.w(CarLog.TAG_TELEMETRY, "No subscribers found for config " + configKey);
             return;
         }
         Map<Long, PersistableBundle> metricBundles = null;
         try {
             metricBundles = ConfigMetricsReportListConverter.convert(report);
         } catch (StatsConversionException ex) {
-            Slog.e(CarLog.TAG_TELEMETRY, "Stats conversion exception for config " + configKey, ex);
+            Slogf.e(CarLog.TAG_TELEMETRY, "Stats conversion exception for config " + configKey, ex);
             return;
         }
         Long metricId;
@@ -222,7 +222,7 @@
                 return;
         }
         if (!metricBundles.containsKey(metricId)) {
-            Slog.w(CarLog.TAG_TELEMETRY,
+            Slogf.w(CarLog.TAG_TELEMETRY,
                     "No reports for metric id " + metricId + " for config " + configKey);
             return;
         }
@@ -240,7 +240,7 @@
                 continue;
             }
             if (!stats.getIsValid()) {
-                Slog.w(CarLog.TAG_TELEMETRY, "Config key " + stats.getId() + " is invalid.");
+                Slogf.w(CarLog.TAG_TELEMETRY, "Config key " + stats.getId() + " is invalid.");
                 failedConfigs.add(mConfigKeyToSubscribers.get(stats.getId()).getMetricsConfig());
             }
         }
@@ -254,7 +254,7 @@
 
     private void pullReportsPeriodically() {
         if (mIsPullingReports) {
-            Slog.d(CarLog.TAG_TELEMETRY, "Stats report will be pulled in "
+            Slogf.d(CarLog.TAG_TELEMETRY, "Stats report will be pulled in "
                     + PULL_REPORTS_PERIOD.toMinutes() + " minutes.");
             mTelemetryHandler.postDelayed(mPullReportsPeriodically, PULL_REPORTS_PERIOD.toMillis());
         }
@@ -271,7 +271,7 @@
             }
         } catch (InvalidProtocolBufferException | StatsUnavailableException e) {
             // If the StatsD is not available, retry in the next pullReportsPeriodically call.
-            Slog.w(CarLog.TAG_TELEMETRY, e);
+            Slogf.w(CarLog.TAG_TELEMETRY, e);
         }
     }
 
@@ -298,7 +298,7 @@
     public void removeDataSubscriber(DataSubscriber subscriber) {
         TelemetryProto.Publisher publisherParam = subscriber.getPublisherParam();
         if (publisherParam.getPublisherCase() != PublisherCase.STATS) {
-            Slog.w(CarLog.TAG_TELEMETRY,
+            Slogf.w(CarLog.TAG_TELEMETRY,
                     "Expected STATS publisher, but received "
                             + publisherParam.getPublisherCase().name());
             return;
@@ -329,7 +329,7 @@
                 mSavedStatsConfigs.remove(key);
                 mSavedStatsConfigs.remove(bundleVersion);
             } catch (StatsUnavailableException e) {
-                Slog.w(CarLog.TAG_TELEMETRY, "Failed to remove config " + configKey
+                Slogf.w(CarLog.TAG_TELEMETRY, "Failed to remove config " + configKey
                         + ". Ignoring the failure. Will retry removing again when"
                         + " removeAllDataSubscribers() is called.", e);
                 // If it cannot remove statsd config, it's less likely it can delete it even if
@@ -407,7 +407,7 @@
             mSavedStatsConfigs.putLong(bundleConfigKey, configKey);
             saveBundle();
         } catch (StatsUnavailableException e) {
-            Slog.w(CarLog.TAG_TELEMETRY, "Failed to add config" + configKey, e);
+            Slogf.w(CarLog.TAG_TELEMETRY, "Failed to add config" + configKey, e);
             // We will notify the failure immediately, as we're expecting StatsManager to be stable.
             onPublisherFailure(
                     getMetricsConfigs(),
@@ -427,7 +427,7 @@
             mSavedStatsConfigs.remove(bundleConfigKey);
             saveBundle();
         } catch (StatsUnavailableException e) {
-            Slog.w(CarLog.TAG_TELEMETRY, "Failed to remove config " + configKey
+            Slogf.w(CarLog.TAG_TELEMETRY, "Failed to remove config " + configKey
                     + ". Ignoring the failure. Will retry removing again when"
                     + " removeAllDataSubscribers() is called.", e);
             // If it cannot remove statsd config, it's less likely it can delete it even if we
diff --git a/service/src/com/android/car/telemetry/publisher/VehiclePropertyPublisher.java b/service/src/com/android/car/telemetry/publisher/VehiclePropertyPublisher.java
index d723d1c..777883d 100644
--- a/service/src/com/android/car/telemetry/publisher/VehiclePropertyPublisher.java
+++ b/service/src/com/android/car/telemetry/publisher/VehiclePropertyPublisher.java
@@ -24,7 +24,6 @@
 import android.os.PersistableBundle;
 import android.os.RemoteException;
 import android.util.ArraySet;
-import android.util.Slog;
 import android.util.SparseArray;
 
 import com.android.car.CarLog;
@@ -33,6 +32,7 @@
 import com.android.car.telemetry.TelemetryProto.Publisher.PublisherCase;
 import com.android.car.telemetry.databroker.DataSubscriber;
 import com.android.internal.util.Preconditions;
+import com.android.server.utils.Slogf;
 
 import java.util.List;
 
@@ -66,7 +66,7 @@
                 @Override
                 public void onEvent(List<CarPropertyEvent> events) throws RemoteException {
                     if (DEBUG) {
-                        Slog.d(CarLog.TAG_TELEMETRY,
+                        Slogf.d(CarLog.TAG_TELEMETRY,
                                 "Received " + events.size() + " vehicle property events");
                     }
                     for (CarPropertyEvent event : events) {
@@ -123,7 +123,7 @@
     public void removeDataSubscriber(DataSubscriber subscriber) {
         TelemetryProto.Publisher publisherParam = subscriber.getPublisherParam();
         if (publisherParam.getPublisherCase() != PublisherCase.VEHICLE_PROPERTY) {
-            Slog.w(CarLog.TAG_TELEMETRY,
+            Slogf.w(CarLog.TAG_TELEMETRY,
                     "Expected VEHICLE_PROPERTY publisher, but received "
                             + publisherParam.getPublisherCase().name());
             return;
diff --git a/service/src/com/android/car/telemetry/systemmonitor/SystemMonitor.java b/service/src/com/android/car/telemetry/systemmonitor/SystemMonitor.java
index 90808b1..28888f5 100644
--- a/service/src/com/android/car/telemetry/systemmonitor/SystemMonitor.java
+++ b/service/src/com/android/car/telemetry/systemmonitor/SystemMonitor.java
@@ -21,10 +21,10 @@
 import android.app.ActivityManager.MemoryInfo;
 import android.content.Context;
 import android.os.Handler;
-import android.util.Slog;
 
 import com.android.car.CarLog;
 import com.android.internal.annotations.VisibleForTesting;
+import com.android.server.utils.Slogf;
 
 import java.io.BufferedReader;
 import java.io.FileReader;
@@ -125,7 +125,7 @@
             String line = reader.readLine();
             String[] vals = line.split("\\s+", NUM_LOADAVG_VALS + 1);
             if (vals.length < NUM_LOADAVG_VALS) {
-                Slog.w(CarLog.TAG_TELEMETRY, "Loadavg wrong format");
+                Slogf.w(CarLog.TAG_TELEMETRY, "Loadavg wrong format");
                 return null;
             }
             CpuLoadavg cpuLoadavg = new CpuLoadavg();
@@ -134,7 +134,7 @@
             cpuLoadavg.mFifteenMinutesVal = Float.parseFloat(vals[2]);
             return cpuLoadavg;
         } catch (IOException | NumberFormatException ex) {
-            Slog.w(CarLog.TAG_TELEMETRY, "Failed to read loadavg file.", ex);
+            Slogf.w(CarLog.TAG_TELEMETRY, "Failed to read loadavg file.", ex);
             return null;
         }
     }
diff --git a/service/src/com/android/car/user/CarUserService.java b/service/src/com/android/car/user/CarUserService.java
index 00cb893..d535c92 100644
--- a/service/src/com/android/car/user/CarUserService.java
+++ b/service/src/com/android/car/user/CarUserService.java
@@ -2265,6 +2265,7 @@
                 (LocationManager) mContext.getSystemService(Context.LOCATION_SERVICE);
         locationManager.setLocationEnabledForUser(
                 /* enabled= */ false, UserHandle.of(UserHandle.USER_SYSTEM));
+        locationManager.setAdasGnssLocationEnabled(false);
     }
 
     /**
diff --git a/service/src/com/android/car/watchdog/CarWatchdogService.java b/service/src/com/android/car/watchdog/CarWatchdogService.java
index 360a559..0e8e9fa 100644
--- a/service/src/com/android/car/watchdog/CarWatchdogService.java
+++ b/service/src/com/android/car/watchdog/CarWatchdogService.java
@@ -158,8 +158,16 @@
                 @Override
                 public void onPolicyChanged(CarPowerPolicy appliedPolicy,
                         CarPowerPolicy accumulatedPolicy) {
-                    mWatchdogPerfHandler.onDisplayStateChanged(
-                            appliedPolicy.isComponentEnabled(PowerComponent.DISPLAY));
+                    boolean isDisplayEnabled =
+                            appliedPolicy.isComponentEnabled(PowerComponent.DISPLAY);
+                    boolean didStateChange = false;
+                    synchronized (mLock) {
+                        didStateChange = mIsDisplayEnabled != isDisplayEnabled;
+                        mIsDisplayEnabled = isDisplayEnabled;
+                    }
+                    if (didStateChange) {
+                        mWatchdogPerfHandler.onDisplayStateChanged(isDisplayEnabled);
+                    }
                 }
             };
 
@@ -168,6 +176,8 @@
     private boolean mReadyToRespond;
     @GuardedBy("mLock")
     private boolean mIsConnected;
+    @GuardedBy("mLock")
+    private boolean mIsDisplayEnabled;
 
     public CarWatchdogService(Context context) {
         this(context, new WatchdogStorage(context));
@@ -191,6 +201,7 @@
             }
             registerToDaemon();
         };
+        mIsDisplayEnabled = true;
     }
 
     @Override
diff --git a/tests/BugReportApp/res/values/strings.xml b/tests/BugReportApp/res/values/strings.xml
index a2fc716..34ec183 100644
--- a/tests/BugReportApp/res/values/strings.xml
+++ b/tests/BugReportApp/res/values/strings.xml
@@ -34,7 +34,7 @@
     <!-- %s is the timestamp of a bugreport. -->
     <string name="bugreport_dialog_add_audio_to_existing">Audio message for bug report at %s</string>
     <string name="bugreport_dialog_recording_finished">Recording finished</string>
-    <string name="bugreport_dialog_in_progress_title">A bug report is already being collected</string>
+    <string name="bugreport_dialog_in_progress_title">Bug report is in progress</string>
     <string name="bugreport_dialog_in_progress_title_finished">A bug report has been collected</string>
     <!-- A button to add audio message to the bugreport. It will show Save button on the dialog. -->
     <string name="bugreport_add_audio_button_text">Add Audio</string>
@@ -45,14 +45,14 @@
     <string name="bugreport_upload_gcs_button_text">Upload to GCS</string>
 
     <string name="toast_permissions_denied">Please grant permissions</string>
-    <string name="toast_bug_report_in_progress">Bug report already being collected</string>
-    <string name="toast_bug_report_started">Bug reporting is started</string>
+    <string name="toast_bug_report_in_progress">Bug report is in progress</string>
+    <string name="toast_bug_report_started">Bug report started</string>
     <string name="toast_status_failed">Bug report failed</string>
     <string name="toast_status_screencap_failed">Screen capture failed</string>
-    <string name="toast_status_dump_state_failed">Dump state failed</string>
+    <string name="toast_status_dump_state_failed">Dumpstate failed</string>
 
     <!-- Notification strings -->
     <string name="notification_bugreport_in_progress">Bug report is in progress</string>
-    <string name="notification_bugreport_finished_title">Bug report is collected</string>
+    <string name="notification_bugreport_finished_title">Bug report has been collected</string>
     <string name="notification_bugreport_channel_name">Bug report status channel</string>
 </resources>
diff --git a/tests/carservice_unit_test/src/com/android/car/telemetry/CarTelemetryServiceTest.java b/tests/carservice_unit_test/src/com/android/car/telemetry/CarTelemetryServiceTest.java
index b177655..dcd45fa 100644
--- a/tests/carservice_unit_test/src/com/android/car/telemetry/CarTelemetryServiceTest.java
+++ b/tests/carservice_unit_test/src/com/android/car/telemetry/CarTelemetryServiceTest.java
@@ -57,7 +57,7 @@
 @RunWith(MockitoJUnitRunner.class)
 @SmallTest
 public class CarTelemetryServiceTest {
-    private static final long TIMEOUT_MS = 5_000L;
+    private static final long TIMEOUT_MS = 15_000L;
     private static final String METRICS_CONFIG_NAME = "my_metrics_config";
     private static final MetricsConfigKey KEY_V1 = new MetricsConfigKey(METRICS_CONFIG_NAME, 1);
     private static final MetricsConfigKey KEY_V2 = new MetricsConfigKey(METRICS_CONFIG_NAME, 2);
diff --git a/tests/carservice_unit_test/src/com/android/car/telemetry/databroker/DataBrokerTest.java b/tests/carservice_unit_test/src/com/android/car/telemetry/databroker/DataBrokerTest.java
index 6983c45..a289a2d 100644
--- a/tests/carservice_unit_test/src/com/android/car/telemetry/databroker/DataBrokerTest.java
+++ b/tests/carservice_unit_test/src/com/android/car/telemetry/databroker/DataBrokerTest.java
@@ -47,7 +47,6 @@
 import com.android.car.telemetry.scriptexecutorinterface.IScriptExecutorListener;
 
 import org.junit.Before;
-import org.junit.Ignore;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
@@ -71,7 +70,7 @@
     private static final int PROP_AREA = 200;
     private static final int PRIORITY_HIGH = 1;
     private static final int PRIORITY_LOW = 100;
-    private static final long TIMEOUT_MS = 5_000L;
+    private static final long TIMEOUT_MS = 15_000L;
     private static final CarPropertyConfig<Integer> PROP_CONFIG =
             CarPropertyConfig.newBuilder(Integer.class, PROP_ID, PROP_AREA).setAccess(
                     CarPropertyConfig.VEHICLE_PROPERTY_ACCESS_READ).build();
@@ -308,7 +307,6 @@
         assertThat(mFakeScriptExecutor.getSavedState()).isEqualTo(mData);
     }
 
-    @Ignore("b/202869761: fix flake")
     @Test
     public void testScheduleNextTask_largeInput_shouldPipeData() throws Exception {
         mData.putBooleanArray("1 MB Array", new boolean [1024 * 1024]);
@@ -320,7 +318,6 @@
         assertThat(mFakeScriptExecutor.getInvokeScriptForLargeInputCount()).isEqualTo(1);
     }
 
-    @Ignore("b/202869761: fix flake")
     @Test
     public void testScheduleNextTask_largeInputPipeIOException_shouldIgnoreCurrentTask()
             throws Exception {
diff --git a/tests/carservice_unit_test/src/com/android/car/user/CarUserServiceTest.java b/tests/carservice_unit_test/src/com/android/car/user/CarUserServiceTest.java
index 1685a71..e72df67 100644
--- a/tests/carservice_unit_test/src/com/android/car/user/CarUserServiceTest.java
+++ b/tests/carservice_unit_test/src/com/android/car/user/CarUserServiceTest.java
@@ -417,6 +417,7 @@
         sendUserUnlockedEvent(UserHandle.USER_SYSTEM);
         verify(mLocationManager).setLocationEnabledForUser(
                 /* enabled= */ false, UserHandle.of(UserHandle.USER_SYSTEM));
+        verify(mLocationManager).setAdasGnssLocationEnabled(false);
     }
 
     /**
