diff --git a/AndroidManifest.xml b/AndroidManifest.xml
index 861fd1d..638c2c4 100644
--- a/AndroidManifest.xml
+++ b/AndroidManifest.xml
@@ -49,6 +49,7 @@
     <uses-permission android:name="com.android.launcher.permission.INSTALL_SHORTCUT"/>
     <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
     <uses-permission android:name="android.permission.BROADCAST_STICKY" />
+    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
     <!-- This tells the activity manager to not delay any of our activity
      start requests, even if they happen immediately after the user
      presses home. -->
diff --git a/res/drawable-hdpi/ic_grade_24dp.png b/res/drawable-hdpi/ic_grade_24dp.png
new file mode 100644
index 0000000..86eecdd
--- /dev/null
+++ b/res/drawable-hdpi/ic_grade_24dp.png
Binary files differ
diff --git a/res/drawable-hdpi/ic_people_24dp.png b/res/drawable-hdpi/ic_people_24dp.png
new file mode 100644
index 0000000..ff698af
--- /dev/null
+++ b/res/drawable-hdpi/ic_people_24dp.png
Binary files differ
diff --git a/res/drawable-hdpi/ic_schedule_24dp.png b/res/drawable-hdpi/ic_schedule_24dp.png
new file mode 100644
index 0000000..f3581d1
--- /dev/null
+++ b/res/drawable-hdpi/ic_schedule_24dp.png
Binary files differ
diff --git a/res/drawable-mdpi/ic_grade_24dp.png b/res/drawable-mdpi/ic_grade_24dp.png
new file mode 100644
index 0000000..d2cbe4c
--- /dev/null
+++ b/res/drawable-mdpi/ic_grade_24dp.png
Binary files differ
diff --git a/res/drawable-mdpi/ic_people_24dp.png b/res/drawable-mdpi/ic_people_24dp.png
new file mode 100644
index 0000000..270e4de
--- /dev/null
+++ b/res/drawable-mdpi/ic_people_24dp.png
Binary files differ
diff --git a/res/drawable-mdpi/ic_schedule_24dp.png b/res/drawable-mdpi/ic_schedule_24dp.png
new file mode 100644
index 0000000..501ee84
--- /dev/null
+++ b/res/drawable-mdpi/ic_schedule_24dp.png
Binary files differ
diff --git a/res/drawable-xhdpi/ic_grade_24dp.png b/res/drawable-xhdpi/ic_grade_24dp.png
new file mode 100644
index 0000000..d65f39d
--- /dev/null
+++ b/res/drawable-xhdpi/ic_grade_24dp.png
Binary files differ
diff --git a/res/drawable-xhdpi/ic_people_24dp.png b/res/drawable-xhdpi/ic_people_24dp.png
new file mode 100644
index 0000000..323981c
--- /dev/null
+++ b/res/drawable-xhdpi/ic_people_24dp.png
Binary files differ
diff --git a/res/drawable-xhdpi/ic_schedule_24dp.png b/res/drawable-xhdpi/ic_schedule_24dp.png
new file mode 100644
index 0000000..2e27936
--- /dev/null
+++ b/res/drawable-xhdpi/ic_schedule_24dp.png
Binary files differ
diff --git a/res/drawable-xxhdpi/ic_grade_24dp.png b/res/drawable-xxhdpi/ic_grade_24dp.png
new file mode 100644
index 0000000..aa58792
--- /dev/null
+++ b/res/drawable-xxhdpi/ic_grade_24dp.png
Binary files differ
diff --git a/res/drawable-xxhdpi/ic_people_24dp.png b/res/drawable-xxhdpi/ic_people_24dp.png
new file mode 100644
index 0000000..6c68435
--- /dev/null
+++ b/res/drawable-xxhdpi/ic_people_24dp.png
Binary files differ
diff --git a/res/drawable-xxhdpi/ic_schedule_24dp.png b/res/drawable-xxhdpi/ic_schedule_24dp.png
new file mode 100644
index 0000000..bfc7273
--- /dev/null
+++ b/res/drawable-xxhdpi/ic_schedule_24dp.png
Binary files differ
diff --git a/res/drawable-xxxhdpi/ic_grade_24dp.png b/res/drawable-xxxhdpi/ic_grade_24dp.png
new file mode 100644
index 0000000..7f38d09
--- /dev/null
+++ b/res/drawable-xxxhdpi/ic_grade_24dp.png
Binary files differ
diff --git a/res/drawable-xxxhdpi/ic_people_24dp.png b/res/drawable-xxxhdpi/ic_people_24dp.png
new file mode 100644
index 0000000..5676f70
--- /dev/null
+++ b/res/drawable-xxxhdpi/ic_people_24dp.png
Binary files differ
diff --git a/res/drawable-xxxhdpi/ic_schedule_24dp.png b/res/drawable-xxxhdpi/ic_schedule_24dp.png
new file mode 100644
index 0000000..b94f4df
--- /dev/null
+++ b/res/drawable-xxxhdpi/ic_schedule_24dp.png
Binary files differ
diff --git a/res/drawable/tab_contacts.xml b/res/drawable/tab_contacts.xml
new file mode 100644
index 0000000..ed3f86b
--- /dev/null
+++ b/res/drawable/tab_contacts.xml
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2014 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+
+<ripple xmlns:android="http://schemas.android.com/apk/res/android"
+    android:color="@color/tab_ripple_color">
+
+    <item>
+        <bitmap android:src="@drawable/ic_people_24dp"
+            android:gravity="center" />
+    </item>
+
+    <item android:id="@android:id/mask">
+        <color android:color="@android:color/white" />
+    </item>
+
+</ripple>
diff --git a/res/drawable/tab_recents.xml b/res/drawable/tab_recents.xml
new file mode 100644
index 0000000..b1a5318
--- /dev/null
+++ b/res/drawable/tab_recents.xml
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2014 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+
+<ripple xmlns:android="http://schemas.android.com/apk/res/android"
+    android:color="@color/tab_ripple_color">
+
+    <item>
+        <bitmap android:src="@drawable/ic_schedule_24dp"
+            android:gravity="center" />
+    </item>
+
+    <item android:id="@android:id/mask">
+        <color android:color="@android:color/white" />
+    </item>
+
+</ripple>
diff --git a/res/drawable/tab_speed_dial.xml b/res/drawable/tab_speed_dial.xml
new file mode 100644
index 0000000..c9c4820
--- /dev/null
+++ b/res/drawable/tab_speed_dial.xml
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2014 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+
+<ripple xmlns:android="http://schemas.android.com/apk/res/android"
+    android:color="@color/tab_ripple_color">
+
+    <item>
+        <bitmap android:src="@drawable/ic_grade_24dp"
+            android:gravity="center" />
+    </item>
+
+    <item android:id="@android:id/mask">
+        <color android:color="@android:color/white" />
+    </item>
+
+</ripple>
diff --git a/res/layout/call_log_list_item.xml b/res/layout/call_log_list_item.xml
index db59b74..910e78f 100644
--- a/res/layout/call_log_list_item.xml
+++ b/res/layout/call_log_list_item.xml
@@ -155,9 +155,5 @@
                   android:layout_width="match_parent"
                   android:layout_height="wrap_content"/>
     </LinearLayout>
-    <!-- Displays the extra link section -->
-    <ViewStub android:id="@+id/link_stub"
-              android:layout="@layout/call_log_list_item_extra"
-              android:layout_width="match_parent"
-              android:layout_height="wrap_content"/>
+
 </LinearLayout>
diff --git a/res/layout/call_log_list_item_extra.xml b/res/layout/call_log_list_item_extra.xml
deleted file mode 100644
index 87b932b..0000000
--- a/res/layout/call_log_list_item_extra.xml
+++ /dev/null
@@ -1,68 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-
-<!--
-  ~ Copyright (C) 2013 The Android Open Source Project
-  ~
-  ~ Licensed under the Apache License, Version 2.0 (the "License");
-  ~ you may not use this file except in compliance with the License.
-  ~ You may obtain a copy of the License at
-  ~
-  ~      http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing, software
-  ~ distributed under the License is distributed on an "AS IS" BASIS,
-  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  ~ See the License for the specific language governing permissions and
-  ~ limitations under the License
-  -->
-
-<!-- Can't use merge here because this is referenced via a ViewStub -->
-<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    android:id="@+id/badge_container"
-    android:layout_width="match_parent"
-    android:layout_height="wrap_content">
-
-    <View android:layout_width="match_parent"
-        android:layout_height="1px"
-        android:background="@color/favorite_contacts_separator_color" />
-
-    <LinearLayout android:id="@+id/badge_link_container"
-        android:layout_width="match_parent"
-        android:layout_height="wrap_content"
-        android:paddingStart="@dimen/call_log_outer_margin"
-        android:paddingEnd="@dimen/call_log_outer_margin"
-        android:paddingTop="@dimen/call_log_item_extra_padding_vertical"
-        android:paddingBottom="@dimen/call_log_item_extra_padding_vertical"
-        android:background="?android:attr/selectableItemBackground"
-        android:clickable="true">
-
-        <ImageView android:id="@+id/badge_image"
-            android:layout_width="wrap_content"
-            android:layout_height="wrap_content"
-            android:tint="@color/call_log_extras_text_color"
-            android:padding="@dimen/call_log_outer_margin" />
-
-        <TextView android:id="@+id/badge_text"
-            android:layout_width="wrap_content"
-            android:layout_height="wrap_content"
-            android:paddingStart="@dimen/call_log_start_margin"
-            android:textColor="@color/call_log_extras_text_color"
-            android:layout_gravity="center_vertical"
-            android:layout_weight="1" />
-
-        <ImageView android:id="@+id/dismiss_button"
-            android:layout_width="wrap_content"
-            android:layout_height="wrap_content"
-            android:padding="@dimen/icon_padding"
-            android:layout_gravity="center_vertical"
-            android:layout_marginEnd="@dimen/call_log_icon_margin"
-            android:src="@drawable/ic_close_dk"
-            android:tint="@color/recent_call_log_item_phone_icon_tint"
-            android:alpha="0.3"
-            android:background="?android:attr/selectableItemBackground"
-            android:visibility="gone"
-            android:contentDescription="@string/description_dismiss" />
-
-    </LinearLayout>
-
-</FrameLayout>
\ No newline at end of file
diff --git a/res/layout/lists_fragment.xml b/res/layout/lists_fragment.xml
index 98a1422..bcf414b 100644
--- a/res/layout/lists_fragment.xml
+++ b/res/layout/lists_fragment.xml
@@ -56,6 +56,7 @@
         android:id="@+id/remove_view"
         android:layout_width="match_parent"
         android:layout_height="@dimen/tab_height"
+        android:layout_marginTop="@dimen/action_bar_height_large"
         android:layout_alignParentTop="true" >
 
         <LinearLayout
diff --git a/res/values-af/strings.xml b/res/values-af/strings.xml
index 77886f1..590a988 100644
--- a/res/values-af/strings.xml
+++ b/res/values-af/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Vertoonopsies"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Klanke en vibrasie"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Toeganklikheid"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Foon-luitoon"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Vibreer ook vir oproepe"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Belbladklanke"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Toonlengte vir belblad"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normaal"</item>
+    <item msgid="6177579030803486015">"Lank"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Vinnige antwoorde"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Oproepe"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Oproeprekeninge"</string>
diff --git a/res/values-am/strings.xml b/res/values-am/strings.xml
index e44a7c1..cd99a30 100644
--- a/res/values-am/strings.xml
+++ b/res/values-am/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">"፣ "</string>
     <string name="display_options_title" msgid="7812852361055667468">"የማሳያ አማራጮች"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"ድምጾች እና ንዝረት"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"ተደራሽነት"</string>
     <string name="ringtone_title" msgid="760362035635084653">"የስልክ ጥሪ ቅላጼ"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"እንዲሁም ለጥሪዎችም ንዘር"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"የመደወያ ሰሌዳ ቅላጼዎች"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"የስልክ ሰሌዳ ድምጽ ርዝመት"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"መደበኛ"</item>
+    <item msgid="6177579030803486015">"ረጅም"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"ፈጣን ምላሾች"</string>
     <string name="call_settings_label" msgid="313434211353070209">"ጥሪዎች"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"የመደወያ መለያዎች"</string>
diff --git a/res/values-ar/strings.xml b/res/values-ar/strings.xml
index b236da8..a450bfb 100644
--- a/res/values-ar/strings.xml
+++ b/res/values-ar/strings.xml
@@ -184,13 +184,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">"، "</string>
     <string name="display_options_title" msgid="7812852361055667468">"خيارات العرض"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"الأصوات والاهتزاز"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"إمكانية الوصول"</string>
     <string name="ringtone_title" msgid="760362035635084653">"نغمة رنين الهاتف"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"الاهتزاز أيضًا مع المكالمات"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"نغمات لوحة الاتصال"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"طول نغمة لوحة الاتصال"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"عادية"</item>
+    <item msgid="6177579030803486015">"طويلة"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"الردود السريعة"</string>
     <string name="call_settings_label" msgid="313434211353070209">"المكالمات"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"حسابات الاتصال"</string>
diff --git a/res/values-az-rAZ/strings.xml b/res/values-az-rAZ/strings.xml
index 11b5bef..7efd086 100644
--- a/res/values-az-rAZ/strings.xml
+++ b/res/values-az-rAZ/strings.xml
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<!-- 
+<!--
   ~ Copyright (C) 2012 The Android Open Source Project
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
@@ -18,7 +18,6 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="8490255569343340580">"Nömrə yığan"</string>
-    <string name="launcherDialer" msgid="8636288196618486553">"Telefon"</string>
     <string name="dialerIconLabel" msgid="6500826552823403796">"Telefon"</string>
     <string name="recentCallsIconLabel" msgid="1419116422359067949">"Zəng jurnalı"</string>
     <string name="menu_sendTextMessage" msgid="6937343460284499306">"Mətnli mesaj göndərin"</string>
@@ -63,18 +62,6 @@
     <string name="sms_disambig_title" msgid="5846266399240630846">"Nömrə seçin"</string>
     <string name="call_disambig_title" msgid="4392886850104795739">"Nömrə seçin"</string>
     <string name="make_primary" msgid="5829291915305113983">"Bu seçimi yadda saxla"</string>
-    <string name="description_image_button_one" msgid="1740638037139856139">"bir"</string>
-    <string name="description_image_button_two" msgid="5882638439003731308">"iki"</string>
-    <string name="description_image_button_three" msgid="8709731759376015180">"üç"</string>
-    <string name="description_image_button_four" msgid="3530239685642246130">"dörd"</string>
-    <string name="description_image_button_five" msgid="1182465427501188413">"beş"</string>
-    <string name="description_image_button_six" msgid="2093656269261415475">"altı"</string>
-    <string name="description_image_button_seven" msgid="2450357020447676481">"yeddi"</string>
-    <string name="description_image_button_eight" msgid="6969435115163287801">"səkkiz"</string>
-    <string name="description_image_button_nine" msgid="7857248695662558323">"doqquz"</string>
-    <string name="description_image_button_star" msgid="3365919907520767866">"ulduz"</string>
-    <string name="description_image_button_zero" msgid="4133108949401820710">"sıfır"</string>
-    <string name="description_image_button_pound" msgid="3039765597595889230">"funt"</string>
     <string name="description_voicemail_button" msgid="3402506823655455591">"Səsli məktub"</string>
     <string name="description_search_button" msgid="3660807558587384889">"axtarış"</string>
     <string name="description_dial_button" msgid="1274091017188142646">"nömrə yığın"</string>
@@ -91,7 +78,6 @@
     <string name="menu_show_all_calls" msgid="7560347482073345885">"Bütün zəngləri göstərin"</string>
     <string name="add_2sec_pause" msgid="9214012315201040129">"2 saniyəlik pauza əlavə edin"</string>
     <string name="add_wait" msgid="3360818652790319634">"Gözləmə əlavə edin"</string>
-    <string name="call_settings" msgid="7666474782093693667">"Ayarlar"</string>
     <string name="menu_newContact" msgid="1209922412763274638">"Yeni kontakt"</string>
     <string name="menu_allContacts" msgid="6948308384034051670">"Bütün kontaktlar"</string>
     <string name="callDetailTitle" msgid="5340227785196217938">"Zəng detalları"</string>
@@ -105,24 +91,17 @@
     <string name="type_voicemail" msgid="5153139450668549908">"Səsli poçt"</string>
     <string name="actionIncomingCall" msgid="6028930669817038600">"Gələn zənglər"</string>
     <string name="description_call_log_play_button" msgid="651182125650429846">"Səsli məktubu oxudun"</string>
-    <string name="description_call_log_incoming_call" msgid="4485427487637250143">"Gələn zəng"</string>
-    <string name="description_call_log_outgoing_call" msgid="604831756853471658">"Gedən zəng"</string>
-    <string name="description_call_log_missed_call" msgid="2242805209983708825">"Buraxılmış zəng"</string>
-    <string name="description_call_log_voicemail" msgid="4600798771975158948">"Səsli məktub"</string>
-    <string name="description_add_contact" msgid="3103414772502485851">"Kontakt əlavə edin"</string>
     <string name="description_view_contact" msgid="5205669345700598415">"<xliff:g id="NAME">%1$s</xliff:g> adlı kontakta baxın"</string>
     <string name="description_call" msgid="3443678121983852666">"Zəng edin: <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"<xliff:g id="NAME">%1$s</xliff:g> mesaj göndər"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"Eşidilməmiş səsli mesaj"</string>
     <string name="description_start_voice_search" msgid="520539488194946012">"Səs axtarışına başlayın"</string>
-    <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
     <string name="menu_callNumber" msgid="997146291983360266">"<xliff:g id="NUMBER">%s</xliff:g> zəng edin"</string>
     <string name="unknown" msgid="740067747858270469">"Naməlum"</string>
     <string name="voicemail" msgid="3851469869202611441">"Səsli poçt"</string>
     <string name="private_num" msgid="6374339738119166953">"Şəxsi nömrə"</string>
     <string name="payphone" msgid="4864313342828942922">"Telefon ödənişi"</string>
     <string name="dialerKeyboardHintText" msgid="5401660096579787344">"Nömrə yığmaq üçün klaviaturadan istifadə ediin"</string>
-    <string name="dialerDialpadHintText" msgid="5824490365898349041">"Zəng əlavə etmək üçün nömrə yığın"</string>
     <string name="callDetailsDurationFormat" msgid="8157706382818184268">"<xliff:g id="MINUTES">%s</xliff:g> dəqiqə <xliff:g id="SECONDS">%s</xliff:g> saniyə"</string>
     <string name="dialog_phone_call_prohibited_message" msgid="6554711866586660441">"Zəng edilmədi"</string>
     <string name="dialog_voicemail_not_ready_message" msgid="4384716252789515378">"Səsli poçtu ayarlamaq üçün Menyu, sonra isə &gt; Ayarlara daxil olun."</string>
@@ -139,21 +118,8 @@
     <string name="call_log_missed_title" msgid="4541142293870638971">"Buraxılmış"</string>
     <string name="recentMissed_empty" msgid="5427113551557296665">"Buraxılmış zəng yoxdur"</string>
     <string name="recentVoicemails_empty" msgid="5163114119598014048">"Səsli məktub yoxdur."</string>
-    <string name="show_all_contacts" msgid="1732256558071778056">"Bütün kontaktları göstər"</string>
     <string name="show_favorites_only" msgid="5520072531022614595">"Yalnız seçilmişləri göstər"</string>
     <string name="call_log_activity_title" msgid="4612824396355272023">"Tarixçə"</string>
-    <string name="dialpad_0_number" msgid="8859392433961251108">"0"</string>
-    <string name="dialpad_1_number" msgid="6536740525419909212">"1"</string>
-    <string name="dialpad_2_number" msgid="4941546415280852148">"2"</string>
-    <string name="dialpad_3_number" msgid="6539414865185536881">"3"</string>
-    <string name="dialpad_4_number" msgid="979988372051042362">"4"</string>
-    <string name="dialpad_5_number" msgid="5492272478939926734">"5"</string>
-    <string name="dialpad_6_number" msgid="8044579516869379093">"6"</string>
-    <string name="dialpad_7_number" msgid="4175113016564167123">"7"</string>
-    <string name="dialpad_8_number" msgid="7949849563865941621">"8"</string>
-    <string name="dialpad_9_number" msgid="4377059952097526576">"9"</string>
-    <string name="show_all_contacts_title" msgid="8395378484578221791">"Bütün kontaktlar"</string>
-    <string name="show_all_contacts_button_text" msgid="8057452310403090131">"Bütün kontaktlar"</string>
     <!-- no translation found for favorite_hidden (5011234945140912047) -->
     <skip />
     <string name="favorite_hidden_undo" msgid="2508998611039406474">"Geri qaytar"</string>
diff --git a/res/values-bg/strings.xml b/res/values-bg/strings.xml
index ec57c0d..5c3cf83 100644
--- a/res/values-bg/strings.xml
+++ b/res/values-bg/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Опции за показване"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Звуци и вибриране"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Достъпност"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Мелодия на телефона"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Вибриране и при обаждания"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Клавиат. за набиране: Мелодии"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Продължителност на звука при набиране"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Нормално"</item>
+    <item msgid="6177579030803486015">"Продължително"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Бързи отговори"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Обаждания"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Профили за обаждане"</string>
diff --git a/res/values-bn-rBD/strings.xml b/res/values-bn-rBD/strings.xml
index 405cf31..5b6ea15 100644
--- a/res/values-bn-rBD/strings.xml
+++ b/res/values-bn-rBD/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"প্রদর্শনের বিকল্পগুলি"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"শব্দ এবং কম্পন"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"অ্যাক্সেসযোগ্যতা"</string>
     <string name="ringtone_title" msgid="760362035635084653">"ফোন রিংটোন"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"এছাড়াও কল এলে কম্পিত করুন"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"ডায়ালপ্যাড টোনগুলি"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"ডায়ালপ্যাড স্বরের দৈর্ঘ্য"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"স্বাভাবিক"</item>
+    <item msgid="6177579030803486015">"দীর্ঘ"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"দ্রুত প্রতিক্রিয়াগুলি"</string>
     <string name="call_settings_label" msgid="313434211353070209">"কল"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"কলিং অ্যাকাউন্টগুলি"</string>
diff --git a/res/values-ca/strings.xml b/res/values-ca/strings.xml
index 7178c67..cd9368b 100644
--- a/res/values-ca/strings.xml
+++ b/res/values-ca/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Opcions de visualització"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Sons i vibració"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Accessibilitat"</string>
     <string name="ringtone_title" msgid="760362035635084653">"So de trucada"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Vibra també per a les trucades"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Tons del teclat"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Durada del to del teclat"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normal"</item>
+    <item msgid="6177579030803486015">"Llarg"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Respostes ràpides"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Trucades"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Comptes per a trucades"</string>
diff --git a/res/values-cs/strings.xml b/res/values-cs/strings.xml
index 34f39b3..3d6bfe2 100644
--- a/res/values-cs/strings.xml
+++ b/res/values-cs/strings.xml
@@ -182,13 +182,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Možnosti zobrazení"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Zvuky a vibrace"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Usnadnění"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Vyzváněcí tón telefonu"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Vibrovat také u volání"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Tóny číselníku"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Délka tónu číselníku"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normální"</item>
+    <item msgid="6177579030803486015">"Dlouhé"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Rychlé odpovědi"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Volání"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Účty pro volání"</string>
diff --git a/res/values-da/strings.xml b/res/values-da/strings.xml
index 365f38b..19ca89a 100644
--- a/res/values-da/strings.xml
+++ b/res/values-da/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Valgmuligheder for visning"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Lyde og vibration"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Hjælpefunktioner"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Ringetone for opkald"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Vibrer også ved opkald"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Toner for numerisk tastatur"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Tonelængde for numerisk tastatur"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normal"</item>
+    <item msgid="6177579030803486015">"Lang"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Hurtigt svar"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Opkald"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Opkaldskonti"</string>
diff --git a/res/values-de/strings.xml b/res/values-de/strings.xml
index 2999e0c..9883057 100644
--- a/res/values-de/strings.xml
+++ b/res/values-de/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Anzeigeoptionen"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Töne und Vibration"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Bedienungshilfen"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Klingelton"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Bei Anrufen auch vibrieren"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Wähltastentöne"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Länge der Wähltastentöne"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normal"</item>
+    <item msgid="6177579030803486015">"Lang"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Kurzantworten"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Anrufe"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Anrufkonten"</string>
diff --git a/res/values-el/strings.xml b/res/values-el/strings.xml
index 196104a..c553c14 100644
--- a/res/values-el/strings.xml
+++ b/res/values-el/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Επιλογές εμφάνισης"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Ήχοι και δόνηση"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Προσβασιμότητα"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Ήχος κλήσης τηλεφώνου"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Επίσης δόνηση για κλήσεις"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Τόνοι πληκτρολογίου κλήσης"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Διάρκεια ήχου πληκτρολογίου κλήσης"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Κανονική"</item>
+    <item msgid="6177579030803486015">"Παρατεταμένη"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Γρήγορες απαντήσεις"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Κλήσεις"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Λογαριασμοί κλήσης"</string>
diff --git a/res/values-en-rGB/strings.xml b/res/values-en-rGB/strings.xml
index 157cddd..5a8e7a6 100644
--- a/res/values-en-rGB/strings.xml
+++ b/res/values-en-rGB/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Display options"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Sounds and vibration"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Accessibility"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Phone ringtone"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Also vibrate for calls"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Dialpad tones"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Dialpad tone length"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normal"</item>
+    <item msgid="6177579030803486015">"Long"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Quick responses"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Calls"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Calling accounts"</string>
diff --git a/res/values-en-rIN/strings.xml b/res/values-en-rIN/strings.xml
index 157cddd..5a8e7a6 100644
--- a/res/values-en-rIN/strings.xml
+++ b/res/values-en-rIN/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Display options"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Sounds and vibration"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Accessibility"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Phone ringtone"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Also vibrate for calls"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Dialpad tones"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Dialpad tone length"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normal"</item>
+    <item msgid="6177579030803486015">"Long"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Quick responses"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Calls"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Calling accounts"</string>
diff --git a/res/values-es-rUS/strings.xml b/res/values-es-rUS/strings.xml
index c621e22..c461035 100644
--- a/res/values-es-rUS/strings.xml
+++ b/res/values-es-rUS/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Opciones de visualización"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Sonidos y vibración"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Accesibilidad"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Tono del teléfono"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Vibrar también en llamadas"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Tonos del teclado"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Longitud del tono del teclado"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normal"</item>
+    <item msgid="6177579030803486015">"Largo"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Respuestas rápidas"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Llamadas"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Cuentas telefónicas"</string>
diff --git a/res/values-es/strings.xml b/res/values-es/strings.xml
index fa91066..c6e029a 100644
--- a/res/values-es/strings.xml
+++ b/res/values-es/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Opciones de visualización"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Sonido y vibración"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Accesibilidad"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Tono del teléfono"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Vibrar también en llamadas"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Tonos del teclado"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Duración del tono del teclado"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Tono normal"</item>
+    <item msgid="6177579030803486015">"Tono largo"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Respuestas rápidas"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Llamadas"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Cuentas de llamadas"</string>
diff --git a/res/values-et-rEE/strings.xml b/res/values-et-rEE/strings.xml
index 5905a41..83b3743 100644
--- a/res/values-et-rEE/strings.xml
+++ b/res/values-et-rEE/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Kuvamisvalikud"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Helid ja vibratsioon"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Juurdepääsetavus"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Telefoni helin"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Vibreeri ka kõnede puhul"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Valimisklahvistiku toonid"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Valimisklahvistiku tooni pikkus"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Tavaline"</item>
+    <item msgid="6177579030803486015">"Pikk"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Kiirvastused"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Kõned"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Helistamiskontod"</string>
diff --git a/res/values-eu-rES/strings.xml b/res/values-eu-rES/strings.xml
index 2393861..2f7bc1b 100644
--- a/res/values-eu-rES/strings.xml
+++ b/res/values-eu-rES/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Bistaratze-aukerak"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Soinuak eta dardara"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Erabilerraztasuna"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Telefonoaren tonua"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Dardara deiak jasotzean ere"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Markagailuaren tonuak"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Markagailuaren tonuaren iraupena"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normala"</item>
+    <item msgid="6177579030803486015">"Luzea"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Erantzun bizkorrak"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Deiak"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Deiak egiteko kontuak"</string>
diff --git a/res/values-fa/strings.xml b/res/values-fa/strings.xml
index f25ee25..3845cc0 100644
--- a/res/values-fa/strings.xml
+++ b/res/values-fa/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">"، "</string>
     <string name="display_options_title" msgid="7812852361055667468">"گزینه‌های نمایش"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"صدا و لرزش"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"دسترس‌پذیری"</string>
     <string name="ringtone_title" msgid="760362035635084653">"آهنگ زنگ تلفن"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"تماس‌‌ها لرزش هم داشته باشند"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"صداهای صفحه شماره‌گیری"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"طول آهنگ صفحه شماره‌گیری"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"عادی"</item>
+    <item msgid="6177579030803486015">"طولانی"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"پاسخ‌های سریع"</string>
     <string name="call_settings_label" msgid="313434211353070209">"تماس‌ها"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"حساب‌های تماس اینترنتی"</string>
diff --git a/res/values-fi/strings.xml b/res/values-fi/strings.xml
index 930bcb5..a0693f8 100644
--- a/res/values-fi/strings.xml
+++ b/res/values-fi/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Näyttöasetukset"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Äänet ja värinä"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Esteettömyys"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Puhelimen soittoääni"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Värinä myös puheluille"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Näppäimistön äänet"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Näppäimistön äänen pituus"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normaali"</item>
+    <item msgid="6177579030803486015">"Pitkä"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Pikavastaukset"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Puhelut"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Puhelutilit"</string>
diff --git a/res/values-fr-rCA/strings.xml b/res/values-fr-rCA/strings.xml
index 1ac4b75..917cdfb 100644
--- a/res/values-fr-rCA/strings.xml
+++ b/res/values-fr-rCA/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Options d\'affichage"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Sons et vibrations"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Accessibilité"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Sonnerie du téléphone"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Vibrer aussi pour les appels"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Tonalités du clavier"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Durée des tonalités du pavé numérique"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normale"</item>
+    <item msgid="6177579030803486015">"Longue"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Réponses rapides"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Appels"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Comptes d\'appel"</string>
diff --git a/res/values-fr/strings.xml b/res/values-fr/strings.xml
index 76405c5..a75074e 100644
--- a/res/values-fr/strings.xml
+++ b/res/values-fr/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Options d\'affichage"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Sons et vibreur"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Accessibilité"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Sonnerie du téléphone"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Vibreur aussi pour les appels"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Son du clavier"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Durée de la tonalité du clavier"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normale"</item>
+    <item msgid="6177579030803486015">"Longue"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Réponses rapides"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Appels"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Comptes téléphoniques"</string>
diff --git a/res/values-gl-rES/strings.xml b/res/values-gl-rES/strings.xml
index 919d051..f1389bd 100644
--- a/res/values-gl-rES/strings.xml
+++ b/res/values-gl-rES/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Opcións de visualización"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Sons e vibración"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Accesibilidade"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Ton de chamada do teléfono"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Vibrar tamén nas chamadas"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Tons do teclado de marcación"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Duración do ton do teclado de marcación"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normal"</item>
+    <item msgid="6177579030803486015">"Longa"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Respostas rápidas"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Chamadas"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Contas de chamadas"</string>
diff --git a/res/values-hi/strings.xml b/res/values-hi/strings.xml
index a829e92..37334a0 100644
--- a/res/values-hi/strings.xml
+++ b/res/values-hi/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"प्रदर्शन विकल्प"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"ध्‍वनि और कंपन"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"सरल उपयोग"</string>
     <string name="ringtone_title" msgid="760362035635084653">"फ़ोन रिंगटोन"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"कॉल के लिए भी कंपन"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"डायलपैड टोन"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"डायलपैड टोन की अवधि"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"सामान्य"</item>
+    <item msgid="6177579030803486015">"लंबी"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"झटपट उत्तर"</string>
     <string name="call_settings_label" msgid="313434211353070209">"कॉल"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"कॉलिंग खाते"</string>
diff --git a/res/values-hr/strings.xml b/res/values-hr/strings.xml
index 66c9675..001ebfe 100644
--- a/res/values-hr/strings.xml
+++ b/res/values-hr/strings.xml
@@ -181,13 +181,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Opcije prikaza"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Zvukovi i vibracije"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Pristupačnost"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Melodija zvona telefona"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Vibracija i za pozive"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Tonovi biranja brojeva"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Duljina zvuka tipkovnice"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Uobičajena"</item>
+    <item msgid="6177579030803486015">"Duga"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Brzi odgovori"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Pozivi"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Pozivanje računa"</string>
diff --git a/res/values-hu/strings.xml b/res/values-hu/strings.xml
index 599d0aa..7162624 100644
--- a/res/values-hu/strings.xml
+++ b/res/values-hu/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Megjelenítési beállítások"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Hangok és rezgés"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Kisegítő lehetőségek"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Telefon csengőhangja"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Rezgés a hívásoknál is"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Tárcsázó hangjai"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Tárcsázási hang hossza"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normál"</item>
+    <item msgid="6177579030803486015">"Hosszú"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Gyors válaszok"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Hívások"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Telefonos fiókok"</string>
diff --git a/res/values-hy-rAM/strings.xml b/res/values-hy-rAM/strings.xml
index a423425..140225f 100644
--- a/res/values-hy-rAM/strings.xml
+++ b/res/values-hy-rAM/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Ցուցադրման ընտրանքներ"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Ձայներ և թրթռում"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Մատչելիություն"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Հեռախոսի զանգերանգ"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Նաև թրթռալ զանգերի ժամանակ"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Թվաշարի ձայներանգներ"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Թվաշարի ձայնային ազդանշանի երկարություն"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Սովորական"</item>
+    <item msgid="6177579030803486015">"Երկար"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Արագ պատասխաններ"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Զանգեր"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Հաշիվներ զանգերի համար"</string>
diff --git a/res/values-in/strings.xml b/res/values-in/strings.xml
index d5b112d..4f82757 100644
--- a/res/values-in/strings.xml
+++ b/res/values-in/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Opsi tampilan"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Suara dan getaran"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Aksesibilitas"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Nada dering ponsel"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Juga getar saat ada panggilan"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Nada tombol nomor"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Panjang nada tombol nomor"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normal"</item>
+    <item msgid="6177579030803486015">"Panjang"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Respons cepat"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Panggilan telepon"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Akun panggilan"</string>
diff --git a/res/values-is-rIS/strings.xml b/res/values-is-rIS/strings.xml
index 66516ef..a84b214 100644
--- a/res/values-is-rIS/strings.xml
+++ b/res/values-is-rIS/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Birtingarvalkostir"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Hljóð og titringur"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Aðgengi"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Hringitónn síma"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Titra líka fyrir símtöl"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Tónar takkaborðs"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Lengd takkatóns"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Venjulegur"</item>
+    <item msgid="6177579030803486015">"Langur"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Snarsvör"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Símtöl"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Símtalareikningar"</string>
diff --git a/res/values-it/strings.xml b/res/values-it/strings.xml
index b7c998c..fd0baf3 100644
--- a/res/values-it/strings.xml
+++ b/res/values-it/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Opzioni di visualizzazione"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Suoni e vibrazione"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Accessibilità"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Suoneria telefono"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Vibrazione anche per chiamate"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Toni tastierino"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Durata tono tastierino"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normale"</item>
+    <item msgid="6177579030803486015">"Lunga"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Risposte rapide"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Chiamate"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Account chiamate"</string>
diff --git a/res/values-iw/strings.xml b/res/values-iw/strings.xml
index 554d14e..f8cbfb9 100644
--- a/res/values-iw/strings.xml
+++ b/res/values-iw/strings.xml
@@ -182,13 +182,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"אפשרויות תצוגה"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"צלילים ורטט"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"נגישות"</string>
     <string name="ringtone_title" msgid="760362035635084653">"רינגטון של טלפון"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"הפעל רטט גם עבור שיחות"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"צלילי לוח החיוג"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"אורך צליל של לוח חיוג"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"רגיל"</item>
+    <item msgid="6177579030803486015">"ארוך"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"תגובות מהירות"</string>
     <string name="call_settings_label" msgid="313434211353070209">"שיחות"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"חשבונות לביצוע שיחות"</string>
diff --git a/res/values-ja/strings.xml b/res/values-ja/strings.xml
index baf15a7..4818608 100644
--- a/res/values-ja/strings.xml
+++ b/res/values-ja/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">"、 "</string>
     <string name="display_options_title" msgid="7812852361055667468">"表示オプション"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"音とバイブレーション"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"ユーザー補助機能"</string>
     <string name="ringtone_title" msgid="760362035635084653">"着信音"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"着信時もバイブレーションON"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"ダイヤルパッドの音"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"ダイヤルパッドの音の長さ"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"標準"</item>
+    <item msgid="6177579030803486015">"長め"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"クイック返信"</string>
     <string name="call_settings_label" msgid="313434211353070209">"通話"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"通話アカウント"</string>
diff --git a/res/values-ka-rGE/strings.xml b/res/values-ka-rGE/strings.xml
index c5eb67b..d280a6e 100644
--- a/res/values-ka-rGE/strings.xml
+++ b/res/values-ka-rGE/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"ეკრანის პარამეტრები"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"კინო და ვიბრაცია"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"მარტივი წვდომა"</string>
     <string name="ringtone_title" msgid="760362035635084653">"ტელეფონის ზარი"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"ზარებზე ასევე ვიბრირება"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"ციფერბლატის ტონები"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"ციფერბლატის ტონის ხანგრძლივობა"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"ჩვეულებრივი"</item>
+    <item msgid="6177579030803486015">"გრძელი"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"სწრაფი პასუხი"</string>
     <string name="call_settings_label" msgid="313434211353070209">"ზარები"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"ანგარიშების გამოძახება"</string>
diff --git a/res/values-kk-rKZ/strings.xml b/res/values-kk-rKZ/strings.xml
index fb7e03a..324ba8d 100644
--- a/res/values-kk-rKZ/strings.xml
+++ b/res/values-kk-rKZ/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Дисплей опциялары"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Дыбыстар мен діріл"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Арнайы мүмкіндіктер"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Телефон қоңырау әуені"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Сондай-ақ, қоңыраулар үшін дірілдету"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Теру тақтасының үндері"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Теру тақтасы дыбысының ұзындығы"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Қалыпты"</item>
+    <item msgid="6177579030803486015">"Ұзақ"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Жылдам жауаптар"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Қоңыраулар"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Есептік жазбаларға қоңыр. шалу"</string>
diff --git a/res/values-km-rKH/strings.xml b/res/values-km-rKH/strings.xml
index 9072e52..780b1de 100644
--- a/res/values-km-rKH/strings.xml
+++ b/res/values-km-rKH/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"ជម្រើសបង្ហាញ"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"សម្លេង និងភាពរំញ័រ"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"លទ្ធភាពប្រើប្រាស់"</string>
     <string name="ringtone_title" msgid="760362035635084653">"សំឡេង​រោទ៍​ទូរស័ព្ទ"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"ញ័រ​សម្រាប់​ការ​ហៅ​ផងដែរ"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"សំឡេង​បន្ទះ​លេខ"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"រយៈពេលនៃសម្លេងបន្ទះលេខ"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"ធម្មតា"</item>
+    <item msgid="6177579030803486015">"វែង"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"ឆ្លើយតប​រហ័ស"</string>
     <string name="call_settings_label" msgid="313434211353070209">"ការហៅ"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"គណនីហៅទូរស័ព្ទ"</string>
diff --git a/res/values-kn-rIN/strings.xml b/res/values-kn-rIN/strings.xml
index fe58d45..532fd90 100644
--- a/res/values-kn-rIN/strings.xml
+++ b/res/values-kn-rIN/strings.xml
@@ -181,13 +181,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"ಪ್ರದರ್ಶನ ಆಯ್ಕೆಗಳು"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"ಧ್ವನಿ ಮತ್ತು ವೈಬ್ರೇಷನ್‌"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"ಪ್ರವೇಶಿಸುವಿಕೆ"</string>
     <string name="ringtone_title" msgid="760362035635084653">"ಫೋನ್ ರಿಂಗ್‌ಟೋನ್"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"ಕರೆಗಳಿಗೂ ಸಹ ವೈಬ್ರೇಟ್‌"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"ಡಯಲ್‌ಪ್ಯಾಡ್‌ ಧ್ವನಿಗಳು"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"ಡಯಲ್‌ಪ್ಯಾಡ್‌ ಟೋನ್ ಅಳತೆ"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"ಸಾಮಾನ್ಯ"</item>
+    <item msgid="6177579030803486015">"ದೀರ್ಘವಾದ"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"ತ್ವರಿತ ಪ್ರತಿಕ್ರಿಯೆಗಳು"</string>
     <string name="call_settings_label" msgid="313434211353070209">"ಕರೆಗಳು"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"ಕರೆ ಮಾಡುವ ಖಾತೆಗಳು"</string>
diff --git a/res/values-ko/strings.xml b/res/values-ko/strings.xml
index e432059..a70c4d7 100644
--- a/res/values-ko/strings.xml
+++ b/res/values-ko/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"표시 옵션"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"소리 및 진동"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"접근성"</string>
     <string name="ringtone_title" msgid="760362035635084653">"전화 벨소리"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"전화 올 때 벨소리와 함께 진동"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"다이얼패드 신호음"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"다이얼패드 신호음 길이"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"보통"</item>
+    <item msgid="6177579030803486015">"길게"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"빠른 응답"</string>
     <string name="call_settings_label" msgid="313434211353070209">"통화"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"통화 계정"</string>
diff --git a/res/values-ky-rKG/strings.xml b/res/values-ky-rKG/strings.xml
index 18b9af9..97ea976 100644
--- a/res/values-ky-rKG/strings.xml
+++ b/res/values-ky-rKG/strings.xml
@@ -207,13 +207,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Параметрлерди көрсөтүү"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Үндөр жана титирөө"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Жеткиликтүүлүк"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Телефондун шыңгыры"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Чалуулар үчүн дагы дирилдесин"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Тергичтин үндөрү"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Тергич обонунун узундугу"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Орточо"</item>
+    <item msgid="6177579030803486015">"Узун"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Тез жооптор"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Чалуулар"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Чалуу каттоо эсептери"</string>
diff --git a/res/values-lo-rLA/strings.xml b/res/values-lo-rLA/strings.xml
index 4c1450b..b5c4359 100644
--- a/res/values-lo-rLA/strings.xml
+++ b/res/values-lo-rLA/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"ຕົວເລືອກການສະແດງຜົນ"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"ສຽງ ແລະ​ສັ່ນ"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"​ການ​ຊ່ວຍ​ເຂົ້າ​ເຖິງ"</string>
     <string name="ringtone_title" msgid="760362035635084653">"ຣິງໂທນໂທລະສັບ"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"ສັ່ນ​ເຕືອນ​ເມື່ອ​ມີ​ການ​ໂທ​ເຂົ້າ"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"ສຽງ​ກົດ​ປຸ່ມ​ໂທ"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"ຄວາມ​ຍາວ​ສຽງ​ແຜ່ນ​ກົດ"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"ປົກ​ກ​ະ​ຕິ"</item>
+    <item msgid="6177579030803486015">"ຍາວ"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"ການຕອບແບບວ່ອງໄວ"</string>
     <string name="call_settings_label" msgid="313434211353070209">"​ການ​ໂທ"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"ບັນ​ຊີ​ໂທ"</string>
diff --git a/res/values-lt/strings.xml b/res/values-lt/strings.xml
index b6649db..c25b942 100644
--- a/res/values-lt/strings.xml
+++ b/res/values-lt/strings.xml
@@ -182,13 +182,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Pateikties parinktys"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Garsai ir vibravimas"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Pritaikymas neįgaliesiems"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Telefono skambėjimo tonas"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Taip pat vibruoti, kai skamb."</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Skambinimo skydelio garsai"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Skambinimo skydelio tono trukmė"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Įprastas"</item>
+    <item msgid="6177579030803486015">"Ilgas"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Greiti atsakai"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Skambučiai"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Skambinimo paskyros"</string>
diff --git a/res/values-lv/strings.xml b/res/values-lv/strings.xml
index c374419..11c545d 100644
--- a/res/values-lv/strings.xml
+++ b/res/values-lv/strings.xml
@@ -181,13 +181,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Attēlojuma opcijas"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Skaņas un vibrācija"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Pieejamība"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Tālruņa zvana signāls"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Izmantot vibrozvanu zvaniem"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Numura sast. tastatūras toņi"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Numuru tastatūras signāla ilgums"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Parasts"</item>
+    <item msgid="6177579030803486015">"Ilgs"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Ātrās atbildes"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Zvani"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Zvanu konti"</string>
diff --git a/res/values-mk-rMK/strings.xml b/res/values-mk-rMK/strings.xml
index 10664a8..f9b9a9a 100644
--- a/res/values-mk-rMK/strings.xml
+++ b/res/values-mk-rMK/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Опции за екран"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Звуци и вибрации"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Пристапност"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Мелодија на телефон"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Вибрации и за повици"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Тонови на подлогата за бирање"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Должина на тонот на подлогата за бирање"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Нормално"</item>
+    <item msgid="6177579030803486015">"Долго"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Брзи одговори"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Повици"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Сметки за повикување"</string>
diff --git a/res/values-ml-rIN/strings.xml b/res/values-ml-rIN/strings.xml
index be7042f..73c3d26 100644
--- a/res/values-ml-rIN/strings.xml
+++ b/res/values-ml-rIN/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"ഡിസ്‌പ്ലേ ഓപ്‌ഷനുകൾ"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"ശബ്‌ദവും വൈബ്രേഷനും"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"പ്രവേശനക്ഷമത"</string>
     <string name="ringtone_title" msgid="760362035635084653">"ഫോൺ റിംഗ്ടോൺ"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"കോളുകൾക്കായും വൈബ്രേറ്റ് ചെയ്യും"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"ഡയൽപാഡ് ടോണുകൾ"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"ഡയൽപാഡ് ടോണിന്റെ ദൈർഘ്യം"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"സാധാരണം"</item>
+    <item msgid="6177579030803486015">"ദൈർഘ്യമുള്ളത്"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"ദ്രുത പ്രതികരണങ്ങൾ"</string>
     <string name="call_settings_label" msgid="313434211353070209">"കോളുകൾ"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"കോളുചെയ്യാനുള്ള അക്കൗണ്ട്"</string>
diff --git a/res/values-mn-rMN/strings.xml b/res/values-mn-rMN/strings.xml
index 2e0aa63..67353fb 100644
--- a/res/values-mn-rMN/strings.xml
+++ b/res/values-mn-rMN/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Сонголтуудыг харуулах"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Дуу болон чичиргээ"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Хандалт"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Утасны хонхны ая"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Дуудлагад бас чичрэх"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Диалпадын ая"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Дугаар цуглуулах хэсгийн дохионы урт"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Энгийн"</item>
+    <item msgid="6177579030803486015">"Урт"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Шуурхай хариунууд"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Дуудлага"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Дуудах акаунт"</string>
diff --git a/res/values-mr-rIN/strings.xml b/res/values-mr-rIN/strings.xml
index db14851..5da83d5 100644
--- a/res/values-mr-rIN/strings.xml
+++ b/res/values-mr-rIN/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"पर्याय प्रदर्शित करा"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"ध्वनी आणि कंपने"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"प्रवेशयोग्यता"</string>
     <string name="ringtone_title" msgid="760362035635084653">"फोन रिंगटोन"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"कॉल साठी कंपन देखील करा"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"डायलपॅड टोन"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"डायलपॅड टोन लांबी"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"सामान्य"</item>
+    <item msgid="6177579030803486015">"लांब"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"द्रुत प्रतिसाद"</string>
     <string name="call_settings_label" msgid="313434211353070209">"कॉल"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"कॉल करण्याची खाती"</string>
diff --git a/res/values-ms-rMY/strings.xml b/res/values-ms-rMY/strings.xml
index 6c45a78..0c3d462 100644
--- a/res/values-ms-rMY/strings.xml
+++ b/res/values-ms-rMY/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Pilihan paparan"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Bunyi dan getaran"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Kebolehaksesan"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Nada dering telefon"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Juga bergetar untuk panggilan"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Nada pad dail"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Panjang nada pad dail"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Biasa"</item>
+    <item msgid="6177579030803486015">"Panjang"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Respons pantas"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Panggilan"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Akaun panggilan"</string>
diff --git a/res/values-my-rMM/strings.xml b/res/values-my-rMM/strings.xml
index c92e007..30d8596 100644
--- a/res/values-my-rMM/strings.xml
+++ b/res/values-my-rMM/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">"၊ "</string>
     <string name="display_options_title" msgid="7812852361055667468">"ပြသမှုအတွက်ရွေးစရာများ"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"အသံများနှင့် တုန်ခါမှု"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"ရယူသုံးနိုင်မှု"</string>
     <string name="ringtone_title" msgid="760362035635084653">"ဖုန်း သံစဉ်"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"ဖုန်းဝင်လျှင် တုန်ခါရန်"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"ဖုန်းဒိုင်ခွက် အသံ"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"နံပါတ်ကွက် နှိပ်သံ ချိန်ညှိ"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"ပုံမှန်"</item>
+    <item msgid="6177579030803486015">"အရှည်"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"အမြန် တုံ့ပြန်ချက်များ"</string>
     <string name="call_settings_label" msgid="313434211353070209">"ခေါ်ဆိုမှုများ"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"ခေါ်ဆိုသော အကောင့်များ"</string>
diff --git a/res/values-nb/strings.xml b/res/values-nb/strings.xml
index d53121a..99a0fba 100644
--- a/res/values-nb/strings.xml
+++ b/res/values-nb/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Visningsalternativer"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Lyder og vibrasjon"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Tilgjengelighet"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Telefonringetone"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Vibrer også når det ringer"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Tastetoner for tastaturet"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Tonelengde for tastaturet"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normal"</item>
+    <item msgid="6177579030803486015">"Lang"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Hurtigsvar"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Anrop"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Ringe kontoer"</string>
diff --git a/res/values-ne-rNP/strings.xml b/res/values-ne-rNP/strings.xml
index c483d57..374409a 100644
--- a/res/values-ne-rNP/strings.xml
+++ b/res/values-ne-rNP/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"विकल्पहरू प्रदर्शन गर्नुहोस्"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"ध्वनि र कम्पन"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"पहुँचता"</string>
     <string name="ringtone_title" msgid="760362035635084653">"फोन रिङटोन"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"कलका लागि कम्पन पनि गर्नुहोस्"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"डायलप्याड ध्वनि"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"डायलप्याड टोन लम्बाइ"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"सामान्य"</item>
+    <item msgid="6177579030803486015">"लामो"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"द्रुत प्रतिक्रियाहरू"</string>
     <string name="call_settings_label" msgid="313434211353070209">"कलहरू"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"खाता कलिङ"</string>
diff --git a/res/values-nl/strings.xml b/res/values-nl/strings.xml
index 0ada884..be42a53 100644
--- a/res/values-nl/strings.xml
+++ b/res/values-nl/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Weergaveopties"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Geluiden en trillingen"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Toegankelijkheid"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Beltoon telefoon"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Ook trillen voor oproepen"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Tonen bij toetsaanslag"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Toonduur toetsenblok"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normaal"</item>
+    <item msgid="6177579030803486015">"Lang"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Snelle reacties"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Oproepen"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Oproepaccounts"</string>
diff --git a/res/values-pl/strings.xml b/res/values-pl/strings.xml
index 6197a56..3dce5b4 100644
--- a/res/values-pl/strings.xml
+++ b/res/values-pl/strings.xml
@@ -182,13 +182,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Opcje wyświetlania"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Dźwięki i wibracje"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Ułatwienia dostępu"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Dzwonek telefonu"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Wibracja przy połączeniach"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Dźwięki klawiatury"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Tony klawiatury"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normalne"</item>
+    <item msgid="6177579030803486015">"Długie"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Szybkie odpowiedzi"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Połączenia"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Konta telefoniczne"</string>
diff --git a/res/values-pt-rPT/strings.xml b/res/values-pt-rPT/strings.xml
index 18d204d..75752a0 100644
--- a/res/values-pt-rPT/strings.xml
+++ b/res/values-pt-rPT/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Opções de visualização"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Sons e vibração"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Acessibilidade"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Toque do telemóvel"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Vibrar também para chamadas"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Tons do teclado"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Duração do tom do teclado"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normal"</item>
+    <item msgid="6177579030803486015">"Longa"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Respostas rápidas"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Chamadas"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Contas de chamadas"</string>
diff --git a/res/values-pt/strings.xml b/res/values-pt/strings.xml
index 867eeff..bc15cdd 100644
--- a/res/values-pt/strings.xml
+++ b/res/values-pt/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Opções de exibição"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Sons e vibração"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Acessibilidade"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Toque do telefone"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Também vibrar para chamadas"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Tons de teclado"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Duração do tom do teclado"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normais"</item>
+    <item msgid="6177579030803486015">"Longos"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Respostas rápidas"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Chamadas"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Contas de chamadas"</string>
diff --git a/res/values-ro/strings.xml b/res/values-ro/strings.xml
index 90f6f3a..629a63f 100644
--- a/res/values-ro/strings.xml
+++ b/res/values-ro/strings.xml
@@ -181,13 +181,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Opțiuni de afișare"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Sunete și vibrații"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Accesibilitate"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Ton de apel al telefonului"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Vibrează și pentru apeluri"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Tonuri pt. tastatura numerică"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Lungimea tonului tastaturii numerice"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normală"</item>
+    <item msgid="6177579030803486015">"Lungă"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Răspunsuri rapide"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Apeluri"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Conturi pentru apelare"</string>
diff --git a/res/values-ru/strings.xml b/res/values-ru/strings.xml
index 7e51710..4ead8e0 100644
--- a/res/values-ru/strings.xml
+++ b/res/values-ru/strings.xml
@@ -182,13 +182,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Упорядочить"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Звуки и вибрация"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Специальные возможности"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Рингтон"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Вибросигнал при вызове"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Звук при наборе номера"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Длительность сигналов при наборе номера"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Обычная"</item>
+    <item msgid="6177579030803486015">"Длинная"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Быстрые ответы"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Вызовы"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Аккаунты для звонков"</string>
diff --git a/res/values-si-rLK/strings.xml b/res/values-si-rLK/strings.xml
index e02e7ac..61da82d 100644
--- a/res/values-si-rLK/strings.xml
+++ b/res/values-si-rLK/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"විකල්ප පෙන්වන්න"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"ශබ්ද සහ කම්පන"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"ප්‍රවේශ්‍යතාවය"</string>
     <string name="ringtone_title" msgid="760362035635084653">"දුරකථන රිගින්ටෝනය"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"ඇමතුම් සඳහා කම්පනයද කරන්න"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"ඩයල්පෑඩ ස්පර්ශක හඬ"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"ඇමතුම් පෑඩයේ නාද දිග"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"සාමාන්‍ය"</item>
+    <item msgid="6177579030803486015">"දීර්ඝ"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"ක්ෂණික ප්‍රතිචාර"</string>
     <string name="call_settings_label" msgid="313434211353070209">"ඇමතුම්"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"ගිණුම් ඇමතීම"</string>
diff --git a/res/values-sk/strings.xml b/res/values-sk/strings.xml
index cd34f5e..f7a2853 100644
--- a/res/values-sk/strings.xml
+++ b/res/values-sk/strings.xml
@@ -182,13 +182,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Možnosti zobrazenia"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Zvuky a vibrovanie"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Dostupnosť"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Tón zvonenia telefónu"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Vibrovať aj pri hovoroch"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Tóny číselnej klávesnice"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Dĺžka zvukov číselnej klávesnice"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normálne"</item>
+    <item msgid="6177579030803486015">"Dlhé"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Rýchle odpovede"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Hovory"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Telefónne účty"</string>
diff --git a/res/values-sl/strings.xml b/res/values-sl/strings.xml
index df12bcd..51948c2 100644
--- a/res/values-sl/strings.xml
+++ b/res/values-sl/strings.xml
@@ -182,13 +182,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Možnosti prikaza"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Zvoki in vibriranje"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Funkcije za ljudi s posebnimi potrebami"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Ton zvonjenja telefona"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Vibriranje tudi za klice"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Toni tipkovnice"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Dolžina pozivnih tonov"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Običajno"</item>
+    <item msgid="6177579030803486015">"Dolgo"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Hitri odgovori"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Klici"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Računi za klicanje"</string>
diff --git a/res/values-sr/strings.xml b/res/values-sr/strings.xml
index 714b3d2..a3ac4dc 100644
--- a/res/values-sr/strings.xml
+++ b/res/values-sr/strings.xml
@@ -181,13 +181,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Опције приказа"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Звуци и вибрација"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Приступачност"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Звук звона телефона"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Вибрирај и за позиве"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Звуци нумеричке тастатуре"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Трајање тонова нумеричке тастатуре"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Нормално"</item>
+    <item msgid="6177579030803486015">"Дугачко"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Брзи одговори"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Позиви"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Налози за позивање"</string>
diff --git a/res/values-sv/strings.xml b/res/values-sv/strings.xml
index 3026efd..9a82ada 100644
--- a/res/values-sv/strings.xml
+++ b/res/values-sv/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Visningsalternativ"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Ljud och vibration"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Tillgänglighet"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Ringsignal"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Vibrera också vid samtal"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Knappsatsljud"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Tonlängd för knappsats"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normal"</item>
+    <item msgid="6177579030803486015">"Lång"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Snabbsvar"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Samtal"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Konton för samtal"</string>
diff --git a/res/values-sw/strings.xml b/res/values-sw/strings.xml
index d78b5a4..b0ab1ff 100644
--- a/res/values-sw/strings.xml
+++ b/res/values-sw/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Chaguo za onyesho"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Sauti na mtetemo"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Zana za walio na matatizo ya kuona au kusikia"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Mlio wa simu"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Tetema simu zinapoingia pia"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Milio ya vitufe vya kupiga simu"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Urefu wa toni ya vitufe vya kupiga simu"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Kawaida"</item>
+    <item msgid="6177579030803486015">"Ndefu"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Majibu ya haraka"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Simu zilizopigwa"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Akaunti za simu"</string>
diff --git a/res/values-ta-rIN/strings.xml b/res/values-ta-rIN/strings.xml
index 14c06c6..41a5c97 100644
--- a/res/values-ta-rIN/strings.xml
+++ b/res/values-ta-rIN/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"திரை விருப்பங்கள்"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"ஒலிகளும் அதிர்வும்"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"அணுகல் தன்மை"</string>
     <string name="ringtone_title" msgid="760362035635084653">"மொபைலின் ரிங்டோன்"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"அழைப்புகளுக்கும் அதிர்வுறு"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"டயல்பேட் ஒலிகள்"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"டயல்பேட் டோன் நீளம்"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"இயல்பு"</item>
+    <item msgid="6177579030803486015">"நீளமானது"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"விரைவு பதில்கள்"</string>
     <string name="call_settings_label" msgid="313434211353070209">"அழைப்புகள்"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"அழைப்பு கணக்குகள்"</string>
diff --git a/res/values-te-rIN/strings.xml b/res/values-te-rIN/strings.xml
index 1d23815..b0114d5 100644
--- a/res/values-te-rIN/strings.xml
+++ b/res/values-te-rIN/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"ప్రదర్శన ఎంపికలు"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"ధ్వనులు మరియు వైబ్రేషన్"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"ప్రాప్యత సామర్థ్యం"</string>
     <string name="ringtone_title" msgid="760362035635084653">"ఫోన్ రింగ్‌టోన్"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"కాల్‌ల కోసం వైబ్రేట్ కూడా చేయి"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"డయల్‌ప్యాడ్ టోన్‌లు"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"డయల్‌ప్యాడ్ టోన్ నిడివి"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"సాధారణం"</item>
+    <item msgid="6177579030803486015">"ఎక్కువ నిడివి"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"శీఘ్ర ప్రతిస్పందనలు"</string>
     <string name="call_settings_label" msgid="313434211353070209">"కాల్‌లు"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"కాల్ చేసే ఖాతాలు"</string>
diff --git a/res/values-th/strings.xml b/res/values-th/strings.xml
index 0578f3c..b3423af 100644
--- a/res/values-th/strings.xml
+++ b/res/values-th/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"ตัวเลือกการแสดง"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"เสียงและการสั่น"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"การเข้าถึง"</string>
     <string name="ringtone_title" msgid="760362035635084653">"เสียงเรียกเข้า"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"สั่นเมื่อมีสายเรียกเข้าด้วย"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"เสียงแป้นหมายเลข"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"ระยะเวลาของเสียงแป้นหมายเลข"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"ปกติ"</item>
+    <item msgid="6177579030803486015">"ยาว"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"คำตอบด่วน"</string>
     <string name="call_settings_label" msgid="313434211353070209">"การโทร"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"บัญชีการโทร"</string>
diff --git a/res/values-tl/strings.xml b/res/values-tl/strings.xml
index 5716d98..2ef0c26 100644
--- a/res/values-tl/strings.xml
+++ b/res/values-tl/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Mga opsyon sa pagpapakita"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Tunog at pag-vibrate"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Pagiging Naa-access"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Ringtone ng telepono"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Mag-vibrate din para sa tawag"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Mga dialpad tone"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Tagal ng tunog ng dialpad"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normal"</item>
+    <item msgid="6177579030803486015">"Mahaba"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Mga mabilisang tugon"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Mga Tawag"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Mga account sa pagtawag"</string>
diff --git a/res/values-tr/strings.xml b/res/values-tr/strings.xml
index ed9da46..702d42d 100644
--- a/res/values-tr/strings.xml
+++ b/res/values-tr/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Görüntüleme seçenekleri"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Ses ve titreşim"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Erişilebilirlik"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Telefon zil sesi"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Çağrılarda ayrıca titret"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Tuş takımı tonları"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Tuş takımı ses uzunluğu"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normal"</item>
+    <item msgid="6177579030803486015">"Uzun"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Hızlı yanıtlar"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Çağrılar"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Çağrı hesapları"</string>
diff --git a/res/values-uk/strings.xml b/res/values-uk/strings.xml
index 6f66301..2095b52 100644
--- a/res/values-uk/strings.xml
+++ b/res/values-uk/strings.xml
@@ -182,13 +182,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Параметри відображення"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Звуки та вібрація"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Спеціальні можливості"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Сигнал дзвінка телефона"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Також вібрувати для дзвінків"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Звуки цифрової клавіатури"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Тривалість сигналу цифрової клавіатури"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Стандартний сигнал"</item>
+    <item msgid="6177579030803486015">"Довгий сигнал"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Швидкі відповіді"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Дзвінки"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Обл. записи для дзвінків"</string>
diff --git a/res/values-ur-rPK/strings.xml b/res/values-ur-rPK/strings.xml
index bcb35a8..4e9097e 100644
--- a/res/values-ur-rPK/strings.xml
+++ b/res/values-ur-rPK/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">"، "</string>
     <string name="display_options_title" msgid="7812852361055667468">"ڈسپلے کے اختیارات"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"آوازیں اور وائبریشن"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Accessibility"</string>
     <string name="ringtone_title" msgid="760362035635084653">"فون رِنگ ٹون"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"کالز کیلئے وائبریٹ بھی کرے"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"ڈائل پیڈ ٹونز"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"ڈائل پیڈ ٹون کی لمبائی"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"حسب معمول"</item>
+    <item msgid="6177579030803486015">"طویل"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"فوری جوابات"</string>
     <string name="call_settings_label" msgid="313434211353070209">"کالز"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"کالنگ اکاؤنٹس"</string>
diff --git a/res/values-uz-rUZ/strings.xml b/res/values-uz-rUZ/strings.xml
index 6ef1ecf..ead63d8 100644
--- a/res/values-uz-rUZ/strings.xml
+++ b/res/values-uz-rUZ/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Ko‘rsatish sozlamalari"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Ovozlar va tebranish"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Maxsus imkoniyatlar"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Telefon uchun rington"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Qo‘ng‘iroq vaqtida tebranish"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Tugmalar tovushi"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Klaviatura ohangi uzunligi"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"O‘rtacha"</item>
+    <item msgid="6177579030803486015">"Uzun"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Tezkor javoblar"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Qo‘ng‘iroqlar"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Qo‘ng‘iroq uchun hisoblar"</string>
diff --git a/res/values-vi/strings.xml b/res/values-vi/strings.xml
index 2353882..99b5ffb 100644
--- a/res/values-vi/strings.xml
+++ b/res/values-vi/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Tùy chọn hiển thị"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Âm thanh và rung"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Trợ năng"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Nhạc chuông điện thoại"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Đồng thời rung khi có cuộc gọi"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Âm bàn phím số"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Độ dài âm bàn phím số"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Thường"</item>
+    <item msgid="6177579030803486015">"Dài"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Trả lời nhanh"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Cuộc gọi"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Tài khoản gọi"</string>
diff --git a/res/values-zh-rCN/strings.xml b/res/values-zh-rCN/strings.xml
index 000f2af..537c6b1 100644
--- a/res/values-zh-rCN/strings.xml
+++ b/res/values-zh-rCN/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">"、 "</string>
     <string name="display_options_title" msgid="7812852361055667468">"显示选项"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"提示音和振动"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"无障碍功能"</string>
     <string name="ringtone_title" msgid="760362035635084653">"手机铃声"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"有来电时响铃并振动"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"拨号键盘提示音"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"拨号键盘提示音长度"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"标准"</item>
+    <item msgid="6177579030803486015">"长"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"快速回复"</string>
     <string name="call_settings_label" msgid="313434211353070209">"通话"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"通话帐户"</string>
diff --git a/res/values-zh-rHK/strings.xml b/res/values-zh-rHK/strings.xml
index 57325ba..8485784 100644
--- a/res/values-zh-rHK/strings.xml
+++ b/res/values-zh-rHK/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">"、 "</string>
     <string name="display_options_title" msgid="7812852361055667468">"顯示選項"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"聲音和震動"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"無障礙功能"</string>
     <string name="ringtone_title" msgid="760362035635084653">"手機鈴聲"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"來電時同時震動"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"撥號盤音效"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"撥號音長度"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"正常"</item>
+    <item msgid="6177579030803486015">"長"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"快速回應"</string>
     <string name="call_settings_label" msgid="313434211353070209">"通話"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"通話帳戶"</string>
diff --git a/res/values-zh-rTW/strings.xml b/res/values-zh-rTW/strings.xml
index e883a42..93f3e31 100644
--- a/res/values-zh-rTW/strings.xml
+++ b/res/values-zh-rTW/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">"、 "</string>
     <string name="display_options_title" msgid="7812852361055667468">"顯示選項"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"音效與振動"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"協助工具"</string>
     <string name="ringtone_title" msgid="760362035635084653">"手機鈴聲"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"來電時同時震動"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"撥號鍵盤音效"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"撥號鍵盤聲調長度"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"一般"</item>
+    <item msgid="6177579030803486015">"長"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"快速回應"</string>
     <string name="call_settings_label" msgid="313434211353070209">"通話"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"通話帳戶"</string>
diff --git a/res/values-zu/strings.xml b/res/values-zu/strings.xml
index f5f85cf..d3a5ff8 100644
--- a/res/values-zu/strings.xml
+++ b/res/values-zu/strings.xml
@@ -180,13 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Izinketho zokubukeka"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Imisindo nokudlidliza"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Ukufinyeleleka"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Ithoni yokukhala yefoni"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Iyadlidliza futhi ngamakholi"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Ukukhala kwephedi yokudayela"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Ubude bethoni bephedi yokudayela"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Okujwayelekile"</item>
+    <item msgid="6177579030803486015">"Kude"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Izimpendulo ezisheshayo"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Amakholi"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Ama-akhawunti wokushaya"</string>
diff --git a/res/values/colors.xml b/res/values/colors.xml
index cd3a804..f697cc8 100644
--- a/res/values/colors.xml
+++ b/res/values/colors.xml
@@ -38,7 +38,6 @@
 
     <!-- Tint of the recent card phone icon -->
     <color name="recent_call_log_item_phone_icon_tint">#000000</color>
-    <color name="call_log_extras_text_color">#0277bd</color>
 
     <!--
          Colour of voicemail progress bar to the right of position indicator.
diff --git a/res/values/dimens.xml b/res/values/dimens.xml
index e4097e3..9de20f3 100644
--- a/res/values/dimens.xml
+++ b/res/values/dimens.xml
@@ -64,9 +64,6 @@
     <dimen name="favorites_row_end_padding">0dp</dimen>
     <dimen name="favorites_row_undo_text_side_padding">32dp</dimen>
 
-    <dimen name="call_log_item_extra_padding_vertical">4dp</dimen>
-
-
     <!-- Size of the star icon on the favorites tile. -->
     <dimen name="favorites_star_icon_size">12dp</dimen>
 
diff --git a/res/values/strings.xml b/res/values/strings.xml
index 78b74e6..13bf845 100644
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -526,9 +526,6 @@
     -->
     <string name="contact_tooltip">Touch image to see all numbers or touch &amp; hold to reorder</string>
 
-    <!-- Content description for dismiss button on badge. [CHAR LIMIT=NONE] -->
-    <string name="description_dismiss">Dismiss</string>
-
     <!-- Remove button that shows up when contact is long-pressed. [CHAR LIMIT=NONE] -->
     <string name="remove_contact">Remove</string>
 
diff --git a/src/com/android/dialer/calllog/CallLogAdapter.java b/src/com/android/dialer/calllog/CallLogAdapter.java
index 36cf710..57efc01 100644
--- a/src/com/android/dialer/calllog/CallLogAdapter.java
+++ b/src/com/android/dialer/calllog/CallLogAdapter.java
@@ -266,12 +266,6 @@
     /** Can be set to true by tests to disable processing of requests. */
     private volatile boolean mRequestProcessingDisabled = false;
 
-    private boolean mIsCallLog = true;
-
-    private View mBadgeContainer;
-    private ImageView mBadgeImageView;
-    private TextView mBadgeText;
-
     private int mCallLogBackgroundColor;
     private int mExpandedBackgroundColor;
     private float mExpandedTranslationZ;
@@ -353,13 +347,12 @@
 
     public CallLogAdapter(Context context, CallFetcher callFetcher,
             ContactInfoHelper contactInfoHelper, CallItemExpandedListener callItemExpandedListener,
-            OnReportButtonClickListener onReportButtonClickListener, boolean isCallLog) {
+            OnReportButtonClickListener onReportButtonClickListener) {
         super(context);
 
         mContext = context;
         mCallFetcher = callFetcher;
         mContactInfoHelper = contactInfoHelper;
-        mIsCallLog = isCallLog;
         mCallItemExpandedListener = callItemExpandedListener;
 
         mOnReportButtonClickListener = onReportButtonClickListener;
@@ -659,17 +652,12 @@
         final long rowId = c.getLong(CallLogQuery.ID);
         views.rowId = rowId;
 
-        // For entries in the call log, check if the day group has changed and display a header
-        // if necessary.
-        if (mIsCallLog) {
-            int currentGroup = getDayGroupForCall(rowId);
-            int previousGroup = getPreviousDayGroup(c);
-            if (currentGroup != previousGroup) {
-                views.dayGroupHeader.setVisibility(View.VISIBLE);
-                views.dayGroupHeader.setText(getGroupDescription(currentGroup));
-            } else {
-                views.dayGroupHeader.setVisibility(View.GONE);
-            }
+        // Check if the day group has changed and display a header if necessary.
+        int currentGroup = getDayGroupForCall(rowId);
+        int previousGroup = getPreviousDayGroup(c);
+        if (currentGroup != previousGroup) {
+            views.dayGroupHeader.setVisibility(View.VISIBLE);
+            views.dayGroupHeader.setText(getGroupDescription(currentGroup));
         } else {
             views.dayGroupHeader.setVisibility(View.GONE);
         }
@@ -689,33 +677,11 @@
         final boolean isVoicemailNumber =
                 mPhoneNumberUtilsWrapper.isVoicemailNumber(accountHandle, number);
 
-        // Where binding and not in the call log, use default behaviour of invoking a call when
-        // tapping the primary view.
-        if (!mIsCallLog) {
-            views.primaryActionView.setOnClickListener(this.mActionListener);
+        // Expand/collapse an actions section for the call log entry when the primary view is tapped.
+        views.primaryActionView.setOnClickListener(this.mExpandCollapseListener);
 
-            // Set return call intent, otherwise null.
-            if (PhoneNumberUtilsWrapper.canPlaceCallsTo(number, numberPresentation)) {
-                // Sets the primary action to call the number.
-                if (isVoicemailNumber) {
-                    views.primaryActionView.setTag(
-                            IntentProvider.getReturnVoicemailCallIntentProvider());
-                } else {
-                    views.primaryActionView.setTag(
-                            IntentProvider.getReturnCallIntentProvider(number));
-                }
-            } else {
-                // Number is not callable, so hide button.
-                views.primaryActionView.setTag(null);
-            }
-        } else {
-            // In the call log, expand/collapse an actions section for the call log entry when
-            // the primary view is tapped.
-            views.primaryActionView.setOnClickListener(this.mExpandCollapseListener);
-
-            // Note: Binding of the action buttons is done as required in configureActionViews
-            // when the user expands the actions ViewStub.
-        }
+        // Note: Binding of the action buttons is done as required in configureActionViews when the
+        // user expands the actions ViewStub.
 
         // Lookup contacts with this number
         NumberWithCountryIso numberCountryIso = new NumberWithCountryIso(number, countryIso);
@@ -828,8 +794,6 @@
             mViewTreeObserver = callLogItemView.getViewTreeObserver();
             mViewTreeObserver.addOnPreDrawListener(this);
         }
-
-        bindBadge(callLogItemView, info, details, callType);
     }
 
     /**
@@ -1073,54 +1037,6 @@
         mCallLogViewsHelper.setActionContentDescriptions(views);
     }
 
-    protected void bindBadge(
-            View view, final ContactInfo info, final PhoneCallDetails details, int callType) {
-        // Do not show badge in call log.
-        if (!mIsCallLog) {
-            final ViewStub stub = (ViewStub) view.findViewById(R.id.link_stub);
-            if (UriUtils.isEncodedContactUri(info.lookupUri)) {
-                if (stub != null) {
-                    mBadgeContainer = stub.inflate();
-                } else {
-                    mBadgeContainer = view.findViewById(R.id.badge_container);
-                }
-
-                mBadgeContainer.setVisibility(View.VISIBLE);
-                mBadgeImageView = (ImageView) mBadgeContainer.findViewById(R.id.badge_image);
-                mBadgeText = (TextView) mBadgeContainer.findViewById(R.id.badge_text);
-
-                final View clickableArea = mBadgeContainer.findViewById(R.id.badge_link_container);
-                if (clickableArea != null) {
-                    clickableArea.setOnClickListener(new View.OnClickListener() {
-                        @Override
-                        public void onClick(View v) {
-                            // If no lookup uri is provided, we need to rely on what information
-                            // we have available; namely the phone number and name.
-                            if (info.lookupUri == null) {
-                                final Intent intent =
-                                        DialtactsActivity.getAddToContactIntent(details.name,
-                                                details.number,
-                                                details.numberType);
-                                DialerUtils.startActivityWithErrorToast(mContext, intent,
-                                        R.string.add_contact_not_available);
-                            } else {
-                                addContactFromLookupUri(info.lookupUri);
-                            }
-                        }
-                    });
-                }
-                mBadgeImageView.setImageResource(R.drawable.ic_person_add_24dp);
-                mBadgeText.setText(R.string.recentCalls_addToContact);
-            } else {
-                // Hide badge if it was previously shown.
-                mBadgeContainer = view.findViewById(R.id.badge_container);
-                if (mBadgeContainer != null) {
-                    mBadgeContainer.setVisibility(View.GONE);
-                }
-            }
-        }
-    }
-
     /** Checks whether the contact info from the call log matches the one from the contacts db. */
     private boolean callLogInfoMatches(ContactInfo callLogInfo, ContactInfo info) {
         // The call log only contains a subset of the fields in the contacts db.
diff --git a/src/com/android/dialer/calllog/CallLogFragment.java b/src/com/android/dialer/calllog/CallLogFragment.java
index 9c95d3e..34dd137 100644
--- a/src/com/android/dialer/calllog/CallLogFragment.java
+++ b/src/com/android/dialer/calllog/CallLogFragment.java
@@ -192,7 +192,7 @@
 
         String currentCountryIso = GeoUtil.getCurrentCountryIso(getActivity());
         mAdapter = ObjectFactory.newCallLogAdapter(getActivity(), this,
-                new ContactInfoHelper(getActivity(), currentCountryIso), this, this, true);
+                new ContactInfoHelper(getActivity(), currentCountryIso), this, this);
         setListAdapter(mAdapter);
         mCallLogQueryHandler = new CallLogQueryHandler(getActivity().getContentResolver(),
                 this, mLogLimit);
diff --git a/src/com/android/dialer/calllog/CallLogQueryHandler.java b/src/com/android/dialer/calllog/CallLogQueryHandler.java
index dfc9c78..761c8e0 100644
--- a/src/com/android/dialer/calllog/CallLogQueryHandler.java
+++ b/src/com/android/dialer/calllog/CallLogQueryHandler.java
@@ -32,11 +32,13 @@
 import android.os.Message;
 import android.provider.CallLog.Calls;
 import android.provider.VoicemailContract.Status;
+import android.provider.VoicemailContract.Voicemails;
 import android.util.Log;
 
 import com.android.common.io.MoreCloseables;
 import com.android.contacts.common.database.NoNullCursorAsyncQueryHandler;
 import com.android.dialer.voicemail.VoicemailStatusHelperImpl;
+
 import com.google.common.collect.Lists;
 
 import java.lang.ref.WeakReference;
@@ -140,15 +142,18 @@
         StringBuilder where = new StringBuilder();
         List<String> selectionArgs = Lists.newArrayList();
 
+        // Ignore voicemails marked as deleted
+        where.append(Voicemails.DELETED);
+        where.append(" = 0");
+
         if (newOnly) {
+            where.append(" AND ");
             where.append(Calls.NEW);
             where.append(" = 1");
         }
 
         if (callType > CALL_TYPE_ALL) {
-            if (where.length() > 0) {
-                where.append(" AND ");
-            }
+            where.append(" AND ");
             // Add a clause to fetch only items of type voicemail.
             where.append(String.format("(%s = ?)", Calls.TYPE));
             // Add a clause to fetch only items newer than the requested date
@@ -156,9 +161,7 @@
         }
 
         if (newerThan > 0) {
-            if (where.length() > 0) {
-                where.append(" AND ");
-            }
+            where.append(" AND ");
             where.append(String.format("(%s > ?)", Calls.DATE));
             selectionArgs.add(Long.toString(newerThan));
         }
diff --git a/src/com/android/dialer/list/ListsFragment.java b/src/com/android/dialer/list/ListsFragment.java
index 45b2f68..0e558bf 100644
--- a/src/com/android/dialer/list/ListsFragment.java
+++ b/src/com/android/dialer/list/ListsFragment.java
@@ -24,9 +24,7 @@
 import com.android.contacts.commonbind.analytics.AnalyticsUtil;
 import com.android.dialer.DialtactsActivity;
 import com.android.dialer.R;
-import com.android.dialer.calllog.CallLogAdapter;
 import com.android.dialer.calllog.CallLogFragment;
-import com.android.dialer.calllog.CallLogQuery;
 import com.android.dialer.calllog.CallLogQueryHandler;
 import com.android.dialer.calllog.ContactInfoHelper;
 import com.android.dialer.util.DialerUtils;
@@ -43,8 +41,7 @@
  * ViewPager containing the lists up above the search bar and pin it against the top of the
  * screen.
  */
-public class ListsFragment extends Fragment implements CallLogQueryHandler.Listener,
-        CallLogAdapter.CallFetcher, ViewPager.OnPageChangeListener {
+public class ListsFragment extends Fragment implements ViewPager.OnPageChangeListener {
 
     private static final boolean DEBUG = DialtactsActivity.DEBUG;
     private static final String TAG = "ListsFragment";
@@ -80,9 +77,7 @@
             new ArrayList<OnPageChangeListener>();
 
     private String[] mTabTitles;
-
-    private CallLogAdapter mCallLogAdapter;
-    private CallLogQueryHandler mCallLogQueryHandler;
+    private int[] mTabIcons;
 
     /**
      * Call shortcuts older than this date (persisted in shared preferences) will not show up in
@@ -156,17 +151,10 @@
         Trace.beginSection(TAG + " onCreate");
         super.onCreate(savedInstanceState);
 
-        mCallLogQueryHandler = new CallLogQueryHandler(getActivity().getContentResolver(),
-                this, 1);
         Trace.beginSection(TAG + " getCurrentCountryIso");
         final String currentCountryIso = GeoUtil.getCurrentCountryIso(getActivity());
         Trace.endSection();
 
-        Trace.beginSection(TAG + " create adapters");
-        mCallLogAdapter = ObjectFactory.newCallLogAdapter(getActivity(), this,
-                new ContactInfoHelper(getActivity(), currentCountryIso), null, null, false);
-
-        Trace.endSection();
         Trace.endSection();
     }
 
@@ -178,8 +166,6 @@
                 DialtactsActivity.SHARED_PREFS_NAME, Context.MODE_PRIVATE);
         mLastCallShortcutDate = prefs.getLong(KEY_LAST_DISMISSED_CALL_SHORTCUT_DATE, 0);
         mActionBar = getActivity().getActionBar();
-        fetchCalls();
-        mCallLogAdapter.setLoading(true);
         if (getUserVisibleHint()) {
             sendScreenViewForPosition(mViewPager.getCurrentItem());
         }
@@ -187,20 +173,6 @@
     }
 
     @Override
-    public void onPause() {
-        // Wipe the cache to refresh the call shortcut item. This is not that expensive because
-        // it only contains one item.
-        mCallLogAdapter.invalidateCache();
-        super.onPause();
-    }
-
-    @Override
-    public void onDestroy() {
-        mCallLogAdapter.stopRequestProcessing();
-        super.onDestroy();
-    }
-
-    @Override
     public View onCreateView(LayoutInflater inflater, ViewGroup container,
             Bundle savedInstanceState) {
         Trace.beginSection(TAG + " onCreateView");
@@ -220,7 +192,13 @@
         mTabTitles[TAB_INDEX_RECENTS] = getResources().getString(R.string.tab_recents);
         mTabTitles[TAB_INDEX_ALL_CONTACTS] = getResources().getString(R.string.tab_all_contacts);
 
+        mTabIcons = new int[TAB_INDEX_COUNT];
+        mTabIcons[TAB_INDEX_SPEED_DIAL] = R.drawable.tab_speed_dial;
+        mTabIcons[TAB_INDEX_RECENTS] = R.drawable.tab_recents;
+        mTabIcons[TAB_INDEX_ALL_CONTACTS] = R.drawable.tab_contacts;
+
         mViewPagerTabs = (ViewPagerTabs) parentView.findViewById(R.id.lists_pager_header);
+        mViewPagerTabs.setTabIcons(mTabIcons);
         mViewPagerTabs.setViewPager(mViewPager);
         addOnPageChangeListener(mViewPagerTabs);
 
@@ -232,31 +210,6 @@
         return parentView;
     }
 
-    @Override
-    public void onVoicemailStatusFetched(Cursor statusCursor) {
-        // no-op
-    }
-
-    @Override
-    public boolean onCallsFetched(Cursor cursor) {
-        mCallLogAdapter.setLoading(false);
-
-        // Save the date of the most recent call log item
-        if (cursor != null && cursor.moveToFirst()) {
-            mCurrentCallShortcutDate = cursor.getLong(CallLogQuery.DATE);
-        }
-
-        mCallLogAdapter.changeCursor(cursor);
-
-        // Return true; took ownership of cursor
-        return true;
-    }
-
-    @Override
-    public void fetchCalls() {
-        mCallLogQueryHandler.fetchCalls(CallLogQueryHandler.CALL_TYPE_ALL, mLastCallShortcutDate);
-    }
-
     public void addOnPageChangeListener(OnPageChangeListener onPageChangeListener) {
         if (!mOnPageChangeListeners.contains(onPageChangeListener)) {
             mOnPageChangeListeners.add(onPageChangeListener);
diff --git a/src/com/android/dialerbind/ObjectFactory.java b/src/com/android/dialerbind/ObjectFactory.java
index 54a5821..e5c39d07 100644
--- a/src/com/android/dialerbind/ObjectFactory.java
+++ b/src/com/android/dialerbind/ObjectFactory.java
@@ -48,9 +48,9 @@
     public static CallLogAdapter newCallLogAdapter(Context context,
             CallFetcher callFetcher, ContactInfoHelper contactInfoHelper,
             CallItemExpandedListener callItemExpandedListener,
-            OnReportButtonClickListener onReportButtonClickListener, boolean isCallLog) {
+            OnReportButtonClickListener onReportButtonClickListener) {
         return new CallLogAdapter(context, callFetcher, contactInfoHelper,
-                callItemExpandedListener, onReportButtonClickListener, isCallLog);
+                callItemExpandedListener, onReportButtonClickListener);
     }
 
     public static DialogFragment getReportDialogFragment(String number) {
diff --git a/tests/src/com/android/dialer/calllog/CallLogAdapterTest.java b/tests/src/com/android/dialer/calllog/CallLogAdapterTest.java
index 9b3e6bc..0f17511 100644
--- a/tests/src/com/android/dialer/calllog/CallLogAdapterTest.java
+++ b/tests/src/com/android/dialer/calllog/CallLogAdapterTest.java
@@ -213,7 +213,7 @@
 
         public TestCallLogAdapter(Context context, CallFetcher callFetcher,
                 ContactInfoHelper contactInfoHelper) {
-            super(context, callFetcher, contactInfoHelper, null, null, false);
+            super(context, callFetcher, contactInfoHelper, null, null);
         }
 
         @Override
