diff --git a/res/values/strings.xml b/res/values/strings.xml
index 0d76780..5b57a92 100644
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -5349,8 +5349,8 @@
     <string name="user_enable_calling_and_sms_confirm_message">Call and SMS history will be shared with this user.</string>
     <!-- Title for the emergency info preference [CHAR LIMIT=40] -->
     <string name="emergency_info_title">Emergency information</string>
-    <!-- Description of the emergency info preference [CHAR LIMIT=80] -->
-    <string name="emergency_info_subtitle">Accessible through lock screen in the emergency dialer</string>
+    <!-- Description of the emergency info preference [CHAR LIMIT=none] -->
+    <string name="emergency_info_subtitle">Accessible by anyone from the emergency dialer without unlocking your phone</string>
 
     <!-- Application Restrictions screen title [CHAR LIMIT=45] -->
     <string name="application_restrictions">Allow apps and content</string>
